From 1daa784438fc4390f84d72eccf592514aaf2266a Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Tue, 1 Aug 2023 21:23:20 +0800
Subject: [PATCH 01/16] Fix the wrong derive path

---
 modules/setting/storage.go      |  18 ++++-
 modules/setting/storage_test.go | 137 ++++++++++++++++++++++++++++++++
 2 files changed, 154 insertions(+), 1 deletion(-)

diff --git a/modules/setting/storage.go b/modules/setting/storage.go
index ed804a910a461..203f9a6013b5c 100644
--- a/modules/setting/storage.go
+++ b/modules/setting/storage.go
@@ -158,10 +158,26 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 
 	switch targetType {
 	case string(LocalStorageType):
-		storage.Path = ConfigSectionKeyString(targetSec, "PATH", filepath.Join(AppDataPath, name))
+		targetPath := ConfigSectionKeyString(targetSec, "PATH", "")
+		if targetPath == "" {
+			targetPath = AppDataPath
+		}
+
+		extraConfigSec := sec
+		if extraConfigSec == nil {
+			extraConfigSec = storageNameSec
+		}
+
+		if extraConfigSec == nil {
+			storage.Path = filepath.Join(targetPath, name)
+		} else {
+			storage.Path = ConfigSectionKeyString(extraConfigSec, "PATH", filepath.Join(targetPath, name))
+		}
+
 		if !filepath.IsAbs(storage.Path) {
 			storage.Path = filepath.Join(AppWorkPath, storage.Path)
 		}
+
 	case string(MinioStorageType):
 		storage.MinioConfig.BasePath = name + "/"
 
diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index 4eda7646e81d0..189e833dd5859 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -90,3 +90,140 @@ STORAGE_TYPE = minio
 	assert.EqualValues(t, "gitea", RepoAvatar.Storage.MinioConfig.Bucket)
 	assert.EqualValues(t, "repo-avatars/", RepoAvatar.Storage.MinioConfig.BasePath)
 }
+
+func Test_getStorageInheritStorageTypeLocal(t *testing.T) {
+	iniStr := `
+[storage]
+STORAGE_TYPE = local
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, "packages/", Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, "repo-archive/", RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, "actions_log/", Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, "actions_artifacts/", Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, "avatars/", Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, "repo-avatars/", RepoAvatar.Storage.Path)
+}
+
+func Test_getStorageInheritStorageTypeLocalPath(t *testing.T) {
+	iniStr := `
+[storage]
+STORAGE_TYPE = local
+PATH = /data/gitea
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/packages", Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/repo-archive", RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, "/data/gitea/actions_log", Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, "/data/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/avatars", Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
+}
+
+func Test_getStorageInheritStorageTypeLocalPathOverride(t *testing.T) {
+	iniStr := `
+[storage]
+STORAGE_TYPE = local
+PATH = /data/gitea
+
+[repo-archive]
+PATH = /data/gitea/archives
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/packages", Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/archives", RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, "/data/gitea/actions_log", Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, "/data/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/avatars", Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
+}
+
+func Test_getStorageInheritStorageTypeLocalPathOverride2(t *testing.T) {
+	iniStr := `
+[storage]
+STORAGE_TYPE = local
+PATH = /data/gitea
+
+[storage.repo-archive]
+PATH = /data/gitea/archives
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/packages", Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/archives", RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, "/data/gitea/actions_log", Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, "/data/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/avatars", Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
+}

From 49dec5ef58ca80822180fadda4d5031ba1932cd4 Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Tue, 1 Aug 2023 21:56:16 +0800
Subject: [PATCH 02/16] Fix test

---
 modules/setting/storage_test.go | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index 189e833dd5859..9a3635d55759e 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -123,6 +123,39 @@ STORAGE_TYPE = local
 	assert.EqualValues(t, "repo-avatars/", RepoAvatar.Storage.Path)
 }
 
+func Test_getStorageInheritStorageTypeLocalDataPath(t *testing.T) {
+	iniStr := `
+[storage]
+STORAGE_TYPE = local
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+	AppDataPath = "/tmp/gitea"
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, "/tmp/gitea/packages", Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, "/tmp/gitea/repo-archive", RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, "/tmp/gitea/actions_log", Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, "/tmp/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, "/tmp/gitea/avatars", Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, "/tmp/gitea/repo-avatars", RepoAvatar.Storage.Path)
+}
+
 func Test_getStorageInheritStorageTypeLocalPath(t *testing.T) {
 	iniStr := `
 [storage]

From c2d88ea1191f62ed74234e0b63dd43cdf1cfcafd Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Wed, 2 Aug 2023 00:04:41 +0800
Subject: [PATCH 03/16] fix test

---
 modules/setting/storage_test.go | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index 9a3635d55759e..d7cfe95d9b733 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -4,6 +4,7 @@
 package setting
 
 import (
+	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -101,26 +102,26 @@ STORAGE_TYPE = local
 
 	assert.NoError(t, loadPackagesFrom(cfg))
 	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, "packages/", Packages.Storage.Path)
+	assert.EqualValues(t, filepath.Join(AppWorkPath, "packages"), Packages.Storage.Path)
 
 	assert.NoError(t, loadRepoArchiveFrom(cfg))
 	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "repo-archive/", RepoArchive.Storage.Path)
+	assert.EqualValues(t, filepath.Join(AppWorkPath, "repo-archive"), RepoArchive.Storage.Path)
 
 	assert.NoError(t, loadActionsFrom(cfg))
 	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, "actions_log/", Actions.LogStorage.Path)
+	assert.EqualValues(t, filepath.Join(AppWorkPath, "actions_log"), Actions.LogStorage.Path)
 
 	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "actions_artifacts/", Actions.ArtifactStorage.Path)
+	assert.EqualValues(t, filepath.Join(AppWorkPath, "actions_artifacts"), Actions.ArtifactStorage.Path)
 
 	assert.NoError(t, loadAvatarsFrom(cfg))
 	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, "avatars/", Avatar.Storage.Path)
+	assert.EqualValues(t, filepath.Join(AppWorkPath, "avatars"), Avatar.Storage.Path)
 
 	assert.NoError(t, loadRepoAvatarFrom(cfg))
 	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, "repo-avatars/", RepoAvatar.Storage.Path)
+	assert.EqualValues(t, filepath.Join(AppWorkPath, "repo-avatars"), RepoAvatar.Storage.Path)
 }
 
 func Test_getStorageInheritStorageTypeLocalDataPath(t *testing.T) {

From 1c6c294517e602ef265931a70aa4338c2977a74d Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Wed, 2 Aug 2023 08:32:00 +0800
Subject: [PATCH 04/16] Fix test

---
 modules/setting/storage_test.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index d7cfe95d9b733..7a1e02dd97fc9 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -102,26 +102,26 @@ STORAGE_TYPE = local
 
 	assert.NoError(t, loadPackagesFrom(cfg))
 	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppWorkPath, "packages"), Packages.Storage.Path)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "packages"), Packages.Storage.Path)
 
 	assert.NoError(t, loadRepoArchiveFrom(cfg))
 	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppWorkPath, "repo-archive"), RepoArchive.Storage.Path)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "repo-archive"), RepoArchive.Storage.Path)
 
 	assert.NoError(t, loadActionsFrom(cfg))
 	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppWorkPath, "actions_log"), Actions.LogStorage.Path)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_log"), Actions.LogStorage.Path)
 
 	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppWorkPath, "actions_artifacts"), Actions.ArtifactStorage.Path)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_artifacts"), Actions.ArtifactStorage.Path)
 
 	assert.NoError(t, loadAvatarsFrom(cfg))
 	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppWorkPath, "avatars"), Avatar.Storage.Path)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "avatars"), Avatar.Storage.Path)
 
 	assert.NoError(t, loadRepoAvatarFrom(cfg))
 	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppWorkPath, "repo-avatars"), RepoAvatar.Storage.Path)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "repo-avatars"), RepoAvatar.Storage.Path)
 }
 
 func Test_getStorageInheritStorageTypeLocalDataPath(t *testing.T) {

From 903dcb940fff7d8193f8cb870f5dd6702accfc7c Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Wed, 2 Aug 2023 12:21:15 +0800
Subject: [PATCH 05/16] code improvement

---
 modules/setting/storage.go | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/modules/setting/storage.go b/modules/setting/storage.go
index 203f9a6013b5c..ec3a87bee39f4 100644
--- a/modules/setting/storage.go
+++ b/modules/setting/storage.go
@@ -153,6 +153,12 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 		return nil, fmt.Errorf("invalid storage type %q", targetType)
 	}
 
+	// extra config section will be read SERVE_DIRECT, PATH, MINIO_BASE_PATH, MINIO_BUCKET to override the targetsec when possible
+	extraConfigSec := sec
+	if extraConfigSec == nil {
+		extraConfigSec = storageNameSec
+	}
+
 	var storage Storage
 	storage.Type = StorageType(targetType)
 
@@ -163,11 +169,6 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 			targetPath = AppDataPath
 		}
 
-		extraConfigSec := sec
-		if extraConfigSec == nil {
-			extraConfigSec = storageNameSec
-		}
-
 		if extraConfigSec == nil {
 			storage.Path = filepath.Join(targetPath, name)
 		} else {
@@ -179,21 +180,16 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 		}
 
 	case string(MinioStorageType):
-		storage.MinioConfig.BasePath = name + "/"
-
 		if err := targetSec.MapTo(&storage.MinioConfig); err != nil {
 			return nil, fmt.Errorf("map minio config failed: %v", err)
 		}
-		// extra config section will be read SERVE_DIRECT, PATH, MINIO_BASE_PATH to override the targetsec
-		extraConfigSec := sec
-		if extraConfigSec == nil {
-			extraConfigSec = storageNameSec
-		}
 
 		if extraConfigSec != nil {
 			storage.MinioConfig.ServeDirect = ConfigSectionKeyBool(extraConfigSec, "SERVE_DIRECT", storage.MinioConfig.ServeDirect)
 			storage.MinioConfig.BasePath = ConfigSectionKeyString(extraConfigSec, "MINIO_BASE_PATH", storage.MinioConfig.BasePath)
 			storage.MinioConfig.Bucket = ConfigSectionKeyString(extraConfigSec, "MINIO_BUCKET", storage.MinioConfig.Bucket)
+		} else {
+			storage.MinioConfig.BasePath = name + "/"
 		}
 	}
 

From 96d0f917da4470e6cf9c96bc897b29a0f4f28751 Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Wed, 2 Aug 2023 12:33:12 +0800
Subject: [PATCH 06/16] Some improvements

---
 modules/setting/storage.go      |  9 +++++----
 modules/setting/storage_test.go | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/modules/setting/storage.go b/modules/setting/storage.go
index ec3a87bee39f4..8ba718927e09f 100644
--- a/modules/setting/storage.go
+++ b/modules/setting/storage.go
@@ -167,16 +167,17 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 		targetPath := ConfigSectionKeyString(targetSec, "PATH", "")
 		if targetPath == "" {
 			targetPath = AppDataPath
+		} else if !filepath.IsAbs(targetPath) {
+			targetPath = filepath.Join(AppDataPath, targetPath)
 		}
 
 		if extraConfigSec == nil {
 			storage.Path = filepath.Join(targetPath, name)
 		} else {
 			storage.Path = ConfigSectionKeyString(extraConfigSec, "PATH", filepath.Join(targetPath, name))
-		}
-
-		if !filepath.IsAbs(storage.Path) {
-			storage.Path = filepath.Join(AppWorkPath, storage.Path)
+			if !filepath.IsAbs(storage.Path) {
+				storage.Path = filepath.Join(AppDataPath, storage.Path)
+			}
 		}
 
 	case string(MinioStorageType):
diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index 7a1e02dd97fc9..20813fd760dd3 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -190,6 +190,39 @@ PATH = /data/gitea
 	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
 }
 
+func Test_getStorageInheritStorageTypeLocalRelativePath(t *testing.T) {
+	iniStr := `
+[storage]
+STORAGE_TYPE = local
+PATH = storages
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "packages"), Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "repo-archive"), RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "actions_log"), Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "actions_artifacts"), Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "avatars"), Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "repo-avatars"), RepoAvatar.Storage.Path)
+}
+
 func Test_getStorageInheritStorageTypeLocalPathOverride(t *testing.T) {
 	iniStr := `
 [storage]

From 833de491b9926eeb746219410ed22de57fdf184d Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Wed, 2 Aug 2023 13:20:23 +0800
Subject: [PATCH 07/16] Add more tests

---
 modules/setting/storage_test.go | 71 +++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)

diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index 20813fd760dd3..aec1e9371d921 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -259,6 +259,77 @@ PATH = /data/gitea/archives
 	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
 }
 
+func Test_getStorageInheritStorageTypeLocalPathOverrideEmpty(t *testing.T) {
+	iniStr := `
+[storage]
+STORAGE_TYPE = local
+PATH = /data/gitea
+
+[repo-archive]
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/packages", Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/repo-archive", RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, "/data/gitea/actions_log", Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, "/data/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/avatars", Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
+}
+
+func Test_getStorageInheritStorageTypeLocalRelativePathOverride(t *testing.T) {
+	iniStr := `
+[storage]
+STORAGE_TYPE = local
+PATH = /data/gitea
+
+[repo-archive]
+PATH = archives
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/packages", Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "archives"), RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, "/data/gitea/actions_log", Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, "/data/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/avatars", Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
+}
+
 func Test_getStorageInheritStorageTypeLocalPathOverride2(t *testing.T) {
 	iniStr := `
 [storage]

From 10f2f5c4ce2139dda7459f333b505c7c5d85c5c7 Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Wed, 2 Aug 2023 13:21:47 +0800
Subject: [PATCH 08/16] Add more test

---
 modules/setting/storage_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index aec1e9371d921..00b057a9751e9 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -196,6 +196,7 @@ func Test_getStorageInheritStorageTypeLocalRelativePath(t *testing.T) {
 STORAGE_TYPE = local
 PATH = storages
 `
+	AppDataPath = "/tmp/data"
 	cfg, err := NewConfigProviderFromData(iniStr)
 	assert.NoError(t, err)
 

From 1705dde10e0943463604bae35d0fc4557b5e038d Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Wed, 2 Aug 2023 13:50:34 +0800
Subject: [PATCH 09/16] Fix bug

---
 modules/setting/storage.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/setting/storage.go b/modules/setting/storage.go
index 8ba718927e09f..ac093cd97aff2 100644
--- a/modules/setting/storage.go
+++ b/modules/setting/storage.go
@@ -185,12 +185,12 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 			return nil, fmt.Errorf("map minio config failed: %v", err)
 		}
 
+		storage.MinioConfig.BasePath = name + "/"
+
 		if extraConfigSec != nil {
 			storage.MinioConfig.ServeDirect = ConfigSectionKeyBool(extraConfigSec, "SERVE_DIRECT", storage.MinioConfig.ServeDirect)
 			storage.MinioConfig.BasePath = ConfigSectionKeyString(extraConfigSec, "MINIO_BASE_PATH", storage.MinioConfig.BasePath)
 			storage.MinioConfig.Bucket = ConfigSectionKeyString(extraConfigSec, "MINIO_BUCKET", storage.MinioConfig.Bucket)
-		} else {
-			storage.MinioConfig.BasePath = name + "/"
 		}
 	}
 

From 928a3cbde9612e2ba0e0d335d51c68609f5c7aaa Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Wed, 2 Aug 2023 15:17:00 +0800
Subject: [PATCH 10/16] improve tests

---
 modules/setting/storage_test.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index 00b057a9751e9..b1a785b80631e 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -268,6 +268,7 @@ PATH = /data/gitea
 
 [repo-archive]
 `
+
 	cfg, err := NewConfigProviderFromData(iniStr)
 	assert.NoError(t, err)
 
@@ -304,6 +305,7 @@ PATH = /data/gitea
 [repo-archive]
 PATH = archives
 `
+	AppDataPath = "/tmp/data"
 	cfg, err := NewConfigProviderFromData(iniStr)
 	assert.NoError(t, err)
 

From b9c2d4ed01e4e5e09065c2adeb59ae27a8cbc00e Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Wed, 2 Aug 2023 16:52:12 +0800
Subject: [PATCH 11/16] Improvement and more tests

---
 modules/setting/storage.go      |  31 +++++++--
 modules/setting/storage_test.go | 107 ++++++++++++++++++++++++++++++++
 2 files changed, 133 insertions(+), 5 deletions(-)

diff --git a/modules/setting/storage.go b/modules/setting/storage.go
index ac093cd97aff2..24dde3196fe67 100644
--- a/modules/setting/storage.go
+++ b/modules/setting/storage.go
@@ -84,6 +84,8 @@ func getDefaultStorageSection(rootCfg ConfigProvider) ConfigSection {
 	return storageSec
 }
 
+// getStorage will find target section and extra special section first and then read override
+// items from extra section
 func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*Storage, error) {
 	if name == "" {
 		return nil, errors.New("no name for storage")
@@ -116,19 +118,31 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 	if targetSec == nil {
 		targetSec = sec
 	}
+
+	targetSecIsStoragename := false
 	if targetSec == nil {
 		targetSec = storageNameSec
+		targetSecIsStoragename = storageNameSec != nil
 	}
+
 	if targetSec == nil {
 		targetSec = getDefaultStorageSection(rootCfg)
 	} else {
 		targetType := targetSec.Key("STORAGE_TYPE").String()
 		switch {
 		case targetType == "":
-			if targetSec.Key("PATH").String() == "" {
-				targetSec = getDefaultStorageSection(rootCfg)
+			if targetSec != storageNameSec && storageNameSec != nil {
+				targetSec = storageNameSec
+				targetSecIsStoragename = true
+				if targetSec.Key("STORAGE_TYPE").String() == "" {
+					return nil, fmt.Errorf("storage section %s.%s has no STORAGE_TYPE", storageSectionName, name)
+				}
 			} else {
-				targetSec.Key("STORAGE_TYPE").SetValue("local")
+				if targetSec.Key("PATH").String() == "" {
+					targetSec = getDefaultStorageSection(rootCfg)
+				} else {
+					targetSec.Key("STORAGE_TYPE").SetValue("local")
+				}
 			}
 		default:
 			newTargetSec, _ := rootCfg.GetSection(storageSectionName + "." + targetType)
@@ -171,10 +185,17 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 			targetPath = filepath.Join(AppDataPath, targetPath)
 		}
 
+		var fallbackPath string
+		if targetSecIsStoragename {
+			fallbackPath = targetPath
+		} else {
+			fallbackPath = filepath.Join(targetPath, name)
+		}
+
 		if extraConfigSec == nil {
-			storage.Path = filepath.Join(targetPath, name)
+			storage.Path = fallbackPath
 		} else {
-			storage.Path = ConfigSectionKeyString(extraConfigSec, "PATH", filepath.Join(targetPath, name))
+			storage.Path = ConfigSectionKeyString(extraConfigSec, "PATH", fallbackPath)
 			if !filepath.IsAbs(storage.Path) {
 				storage.Path = filepath.Join(AppDataPath, storage.Path)
 			}
diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index b1a785b80631e..f8a6891bfae19 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -368,3 +368,110 @@ PATH = /data/gitea/archives
 	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
 	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
 }
+
+func Test_getStorageInheritStorageTypeLocalPathOverride3(t *testing.T) {
+	iniStr := `
+[storage.repo-archive]
+STORAGE_TYPE = local
+PATH = /data/gitea/archives
+`
+	AppDataPath = "/tmp/data"
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "packages"), Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/archives", RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_log"), Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_artifacts"), Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "avatars"), Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "repo-avatars"), RepoAvatar.Storage.Path)
+}
+
+func Test_getStorageInheritStorageTypeLocalPathOverride4(t *testing.T) {
+	iniStr := `
+[storage.repo-archive]
+STORAGE_TYPE = local
+PATH = /data/gitea/archives
+
+[repo-archive]
+PATH = /tmp/gitea/archives
+`
+	AppDataPath = "/tmp/data"
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "packages"), Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, "/tmp/gitea/archives", RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_log"), Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_artifacts"), Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "avatars"), Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "repo-avatars"), RepoAvatar.Storage.Path)
+}
+
+func Test_getStorageInheritStorageTypeLocalPathOverride5(t *testing.T) {
+	iniStr := `
+[storage.repo-archive]
+STORAGE_TYPE = local
+PATH = /data/gitea/archives
+
+[repo-archive]
+`
+	AppDataPath = "/tmp/data"
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	assert.EqualValues(t, "local", Packages.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "packages"), Packages.Storage.Path)
+
+	assert.NoError(t, loadRepoArchiveFrom(cfg))
+	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
+	assert.EqualValues(t, "/data/gitea/archives", RepoArchive.Storage.Path)
+
+	assert.NoError(t, loadActionsFrom(cfg))
+	assert.EqualValues(t, "local", Actions.LogStorage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_log"), Actions.LogStorage.Path)
+
+	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_artifacts"), Actions.ArtifactStorage.Path)
+
+	assert.NoError(t, loadAvatarsFrom(cfg))
+	assert.EqualValues(t, "local", Avatar.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "avatars"), Avatar.Storage.Path)
+
+	assert.NoError(t, loadRepoAvatarFrom(cfg))
+	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
+	assert.EqualValues(t, filepath.Join(AppDataPath, "repo-avatars"), RepoAvatar.Storage.Path)
+}

From 15ff8e460a7af1e21ff86a13a08740297e21575d Mon Sep 17 00:00:00 2001
From: wxiaoguang <wxiaoguang@gmail.com>
Date: Wed, 2 Aug 2023 17:04:56 +0800
Subject: [PATCH 12/16] refactor

---
 modules/setting/storage_test.go | 413 ++++++++------------------------
 1 file changed, 96 insertions(+), 317 deletions(-)

diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index f8a6891bfae19..6198e8b090268 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -92,386 +92,165 @@ STORAGE_TYPE = minio
 	assert.EqualValues(t, "repo-avatars/", RepoAvatar.Storage.MinioConfig.BasePath)
 }
 
-func Test_getStorageInheritStorageTypeLocal(t *testing.T) {
-	iniStr := `
-[storage]
-STORAGE_TYPE = local
-`
+type testLocalStoragePathCase struct {
+	loader       func(rootCfg ConfigProvider) error
+	storagePtr   **Storage
+	expectedPath string
+}
+
+func testLocalStoragePath(t *testing.T, appDataPath, iniStr string, cases []testLocalStoragePathCase) {
 	cfg, err := NewConfigProviderFromData(iniStr)
 	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "packages"), Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "repo-archive"), RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_log"), Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_artifacts"), Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "avatars"), Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "repo-avatars"), RepoAvatar.Storage.Path)
+	AppDataPath = appDataPath
+	for _, c := range cases {
+		assert.NoError(t, c.loader(cfg))
+		storage := *c.storagePtr
+
+		assert.EqualValues(t, "local", storage.Type)
+
+		assert.True(t, filepath.IsAbs(storage.Path))
+		expected, err := filepath.Abs(c.expectedPath)
+		assert.NoError(t, err)
+		actual, err := filepath.Abs(storage.Path)
+		assert.NoError(t, err)
+		assert.EqualValues(t, expected, actual)
+	}
 }
 
-func Test_getStorageInheritStorageTypeLocalDataPath(t *testing.T) {
-	iniStr := `
+func Test_getStorageInheritStorageTypeLocal(t *testing.T) {
+	testLocalStoragePath(t, "/tmp/data", `
 [storage]
 STORAGE_TYPE = local
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-	AppDataPath = "/tmp/gitea"
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, "/tmp/gitea/packages", Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "/tmp/gitea/repo-archive", RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, "/tmp/gitea/actions_log", Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "/tmp/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, "/tmp/gitea/avatars", Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, "/tmp/gitea/repo-avatars", RepoAvatar.Storage.Path)
+`, []testLocalStoragePathCase{
+		{loadPackagesFrom, &Packages.Storage, "/tmp/data/packages"},
+		{loadRepoArchiveFrom, &RepoArchive.Storage, "/tmp/data/repo-archive"},
+		{loadActionsFrom, &Actions.LogStorage, "/tmp/data/actions_log"},
+		{loadAvatarsFrom, &Avatar.Storage, "/tmp/data/avatars"},
+		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/tmp/data/repo-avatars"},
+	})
 }
 
 func Test_getStorageInheritStorageTypeLocalPath(t *testing.T) {
-	iniStr := `
+	testLocalStoragePath(t, "/tmp/data", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/packages", Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/repo-archive", RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, "/data/gitea/actions_log", Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "/data/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/avatars", Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
+`, []testLocalStoragePathCase{
+		{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) {
-	iniStr := `
+	testLocalStoragePath(t, "/tmp/data", `
 [storage]
 STORAGE_TYPE = local
 PATH = storages
-`
-	AppDataPath = "/tmp/data"
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "packages"), Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "repo-archive"), RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "actions_log"), Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "actions_artifacts"), Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "avatars"), Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "storages", "repo-avatars"), RepoAvatar.Storage.Path)
+`, []testLocalStoragePathCase{
+		{loadPackagesFrom, &Packages.Storage, "/tmp/data/storages/packages"},
+		{loadRepoArchiveFrom, &RepoArchive.Storage, "/tmp/data/storages/repo-archive"},
+		{loadActionsFrom, &Actions.LogStorage, "/tmp/data/storages/actions_log"},
+		{loadAvatarsFrom, &Avatar.Storage, "/tmp/data/storages/avatars"},
+		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/tmp/data/storages/repo-avatars"},
+	})
 }
 
 func Test_getStorageInheritStorageTypeLocalPathOverride(t *testing.T) {
-	iniStr := `
+	testLocalStoragePath(t, "/tmp/data", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
 
 [repo-archive]
-PATH = /data/gitea/archives
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/packages", Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/archives", RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, "/data/gitea/actions_log", Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "/data/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/avatars", Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
+PATH = /data/gitea/the-archives-dir
+`, []testLocalStoragePathCase{
+		{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) {
-	iniStr := `
+	testLocalStoragePath(t, "/tmp/data", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
 
 [repo-archive]
-`
-
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/packages", Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/repo-archive", RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, "/data/gitea/actions_log", Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "/data/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/avatars", Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
+`, []testLocalStoragePathCase{
+		{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) {
-	iniStr := `
+	testLocalStoragePath(t, "/tmp/data", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
 
 [repo-archive]
-PATH = archives
-`
-	AppDataPath = "/tmp/data"
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/packages", Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "archives"), RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, "/data/gitea/actions_log", Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "/data/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/avatars", Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
-}
-
-func Test_getStorageInheritStorageTypeLocalPathOverride2(t *testing.T) {
-	iniStr := `
-[storage]
-STORAGE_TYPE = local
-PATH = /data/gitea
-
-[storage.repo-archive]
-PATH = /data/gitea/archives
-`
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/packages", Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/archives", RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, "/data/gitea/actions_log", Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, "/data/gitea/actions_artifacts", Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/avatars", Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/repo-avatars", RepoAvatar.Storage.Path)
+PATH = the-archives-dir
+`, []testLocalStoragePathCase{
+		{loadPackagesFrom, &Packages.Storage, "/data/gitea/packages"},
+		{loadRepoArchiveFrom, &RepoArchive.Storage, "/tmp/data/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) {
-	iniStr := `
+	testLocalStoragePath(t, "/tmp/data", `
 [storage.repo-archive]
 STORAGE_TYPE = local
 PATH = /data/gitea/archives
-`
-	AppDataPath = "/tmp/data"
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "packages"), Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/archives", RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_log"), Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_artifacts"), Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "avatars"), Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "repo-avatars"), RepoAvatar.Storage.Path)
+`, []testLocalStoragePathCase{
+		{loadPackagesFrom, &Packages.Storage, "/tmp/data/packages"},
+		{loadRepoArchiveFrom, &RepoArchive.Storage, "/data/gitea/archives"},
+		{loadActionsFrom, &Actions.LogStorage, "/tmp/data/actions_log"},
+		{loadAvatarsFrom, &Avatar.Storage, "/tmp/data/avatars"},
+		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/tmp/data/repo-avatars"},
+	})
 }
 
 func Test_getStorageInheritStorageTypeLocalPathOverride4(t *testing.T) {
-	iniStr := `
+	testLocalStoragePath(t, "/tmp/data", `
 [storage.repo-archive]
 STORAGE_TYPE = local
 PATH = /data/gitea/archives
 
 [repo-archive]
 PATH = /tmp/gitea/archives
-`
-	AppDataPath = "/tmp/data"
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "packages"), Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "/tmp/gitea/archives", RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_log"), Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_artifacts"), Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "avatars"), Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "repo-avatars"), RepoAvatar.Storage.Path)
+`, []testLocalStoragePathCase{
+		{loadPackagesFrom, &Packages.Storage, "/tmp/data/packages"},
+		{loadRepoArchiveFrom, &RepoArchive.Storage, "/tmp/gitea/archives"},
+		{loadActionsFrom, &Actions.LogStorage, "/tmp/data/actions_log"},
+		{loadAvatarsFrom, &Avatar.Storage, "/tmp/data/avatars"},
+		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/tmp/data/repo-avatars"},
+	})
 }
 
 func Test_getStorageInheritStorageTypeLocalPathOverride5(t *testing.T) {
-	iniStr := `
+	testLocalStoragePath(t, "/tmp/data", `
 [storage.repo-archive]
 STORAGE_TYPE = local
 PATH = /data/gitea/archives
 
 [repo-archive]
-`
-	AppDataPath = "/tmp/data"
-	cfg, err := NewConfigProviderFromData(iniStr)
-	assert.NoError(t, err)
-
-	assert.NoError(t, loadPackagesFrom(cfg))
-	assert.EqualValues(t, "local", Packages.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "packages"), Packages.Storage.Path)
-
-	assert.NoError(t, loadRepoArchiveFrom(cfg))
-	assert.EqualValues(t, "local", RepoArchive.Storage.Type)
-	assert.EqualValues(t, "/data/gitea/archives", RepoArchive.Storage.Path)
-
-	assert.NoError(t, loadActionsFrom(cfg))
-	assert.EqualValues(t, "local", Actions.LogStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_log"), Actions.LogStorage.Path)
-
-	assert.EqualValues(t, "local", Actions.ArtifactStorage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "actions_artifacts"), Actions.ArtifactStorage.Path)
-
-	assert.NoError(t, loadAvatarsFrom(cfg))
-	assert.EqualValues(t, "local", Avatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "avatars"), Avatar.Storage.Path)
-
-	assert.NoError(t, loadRepoAvatarFrom(cfg))
-	assert.EqualValues(t, "local", RepoAvatar.Storage.Type)
-	assert.EqualValues(t, filepath.Join(AppDataPath, "repo-avatars"), RepoAvatar.Storage.Path)
+`, []testLocalStoragePathCase{
+		{loadPackagesFrom, &Packages.Storage, "/tmp/data/packages"},
+		{loadRepoArchiveFrom, &RepoArchive.Storage, "/data/gitea/archives"},
+		{loadActionsFrom, &Actions.LogStorage, "/tmp/data/actions_log"},
+		{loadAvatarsFrom, &Avatar.Storage, "/tmp/data/avatars"},
+		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/tmp/data/repo-avatars"},
+	})
 }

From 98d34265224fdb3d3c64a138d04c9dd0c85b5dad Mon Sep 17 00:00:00 2001
From: wxiaoguang <wxiaoguang@gmail.com>
Date: Wed, 2 Aug 2023 17:18:53 +0800
Subject: [PATCH 13/16] use a different appdata

---
 modules/setting/storage_test.go | 64 ++++++++++++++++-----------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index 6198e8b090268..a32bae05c4f87 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -118,20 +118,20 @@ func testLocalStoragePath(t *testing.T, appDataPath, iniStr string, cases []test
 }
 
 func Test_getStorageInheritStorageTypeLocal(t *testing.T) {
-	testLocalStoragePath(t, "/tmp/data", `
+	testLocalStoragePath(t, "/appdata", `
 [storage]
 STORAGE_TYPE = local
 `, []testLocalStoragePathCase{
-		{loadPackagesFrom, &Packages.Storage, "/tmp/data/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/tmp/data/repo-archive"},
-		{loadActionsFrom, &Actions.LogStorage, "/tmp/data/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/tmp/data/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/tmp/data/repo-avatars"},
+		{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, "/tmp/data", `
+	testLocalStoragePath(t, "/appdata", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
@@ -145,21 +145,21 @@ PATH = /data/gitea
 }
 
 func Test_getStorageInheritStorageTypeLocalRelativePath(t *testing.T) {
-	testLocalStoragePath(t, "/tmp/data", `
+	testLocalStoragePath(t, "/appdata", `
 [storage]
 STORAGE_TYPE = local
 PATH = storages
 `, []testLocalStoragePathCase{
-		{loadPackagesFrom, &Packages.Storage, "/tmp/data/storages/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/tmp/data/storages/repo-archive"},
-		{loadActionsFrom, &Actions.LogStorage, "/tmp/data/storages/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/tmp/data/storages/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/tmp/data/storages/repo-avatars"},
+		{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, "/tmp/data", `
+	testLocalStoragePath(t, "/appdata", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
@@ -176,7 +176,7 @@ PATH = /data/gitea/the-archives-dir
 }
 
 func Test_getStorageInheritStorageTypeLocalPathOverrideEmpty(t *testing.T) {
-	testLocalStoragePath(t, "/tmp/data", `
+	testLocalStoragePath(t, "/appdata", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
@@ -192,7 +192,7 @@ PATH = /data/gitea
 }
 
 func Test_getStorageInheritStorageTypeLocalRelativePathOverride(t *testing.T) {
-	testLocalStoragePath(t, "/tmp/data", `
+	testLocalStoragePath(t, "/appdata", `
 [storage]
 STORAGE_TYPE = local
 PATH = /data/gitea
@@ -201,7 +201,7 @@ PATH = /data/gitea
 PATH = the-archives-dir
 `, []testLocalStoragePathCase{
 		{loadPackagesFrom, &Packages.Storage, "/data/gitea/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/tmp/data/the-archives-dir"},
+		{loadRepoArchiveFrom, &RepoArchive.Storage, "/appdata/the-archives-dir"},
 		{loadActionsFrom, &Actions.LogStorage, "/data/gitea/actions_log"},
 		{loadAvatarsFrom, &Avatar.Storage, "/data/gitea/avatars"},
 		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/data/gitea/repo-avatars"},
@@ -209,21 +209,21 @@ PATH = the-archives-dir
 }
 
 func Test_getStorageInheritStorageTypeLocalPathOverride3(t *testing.T) {
-	testLocalStoragePath(t, "/tmp/data", `
+	testLocalStoragePath(t, "/appdata", `
 [storage.repo-archive]
 STORAGE_TYPE = local
 PATH = /data/gitea/archives
 `, []testLocalStoragePathCase{
-		{loadPackagesFrom, &Packages.Storage, "/tmp/data/packages"},
+		{loadPackagesFrom, &Packages.Storage, "/appdata/packages"},
 		{loadRepoArchiveFrom, &RepoArchive.Storage, "/data/gitea/archives"},
-		{loadActionsFrom, &Actions.LogStorage, "/tmp/data/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/tmp/data/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/tmp/data/repo-avatars"},
+		{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, "/tmp/data", `
+	testLocalStoragePath(t, "/appdata", `
 [storage.repo-archive]
 STORAGE_TYPE = local
 PATH = /data/gitea/archives
@@ -231,26 +231,26 @@ PATH = /data/gitea/archives
 [repo-archive]
 PATH = /tmp/gitea/archives
 `, []testLocalStoragePathCase{
-		{loadPackagesFrom, &Packages.Storage, "/tmp/data/packages"},
+		{loadPackagesFrom, &Packages.Storage, "/appdata/packages"},
 		{loadRepoArchiveFrom, &RepoArchive.Storage, "/tmp/gitea/archives"},
-		{loadActionsFrom, &Actions.LogStorage, "/tmp/data/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/tmp/data/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/tmp/data/repo-avatars"},
+		{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, "/tmp/data", `
+	testLocalStoragePath(t, "/appdata", `
 [storage.repo-archive]
 STORAGE_TYPE = local
 PATH = /data/gitea/archives
 
 [repo-archive]
 `, []testLocalStoragePathCase{
-		{loadPackagesFrom, &Packages.Storage, "/tmp/data/packages"},
+		{loadPackagesFrom, &Packages.Storage, "/appdata/packages"},
 		{loadRepoArchiveFrom, &RepoArchive.Storage, "/data/gitea/archives"},
-		{loadActionsFrom, &Actions.LogStorage, "/tmp/data/actions_log"},
-		{loadAvatarsFrom, &Avatar.Storage, "/tmp/data/avatars"},
-		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/tmp/data/repo-avatars"},
+		{loadActionsFrom, &Actions.LogStorage, "/appdata/actions_log"},
+		{loadAvatarsFrom, &Avatar.Storage, "/appdata/avatars"},
+		{loadRepoAvatarFrom, &RepoAvatar.Storage, "/appdata/repo-avatars"},
 	})
 }

From 3b35864eae7968fc44a034eb5e4db016bd8641be Mon Sep 17 00:00:00 2001
From: wxiaoguang <wxiaoguang@gmail.com>
Date: Wed, 2 Aug 2023 17:24:08 +0800
Subject: [PATCH 14/16] fix

---
 modules/setting/storage_test.go | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index a32bae05c4f87..7a6b31d9b9580 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -107,13 +107,8 @@ func testLocalStoragePath(t *testing.T, appDataPath, iniStr string, cases []test
 		storage := *c.storagePtr
 
 		assert.EqualValues(t, "local", storage.Type)
-
 		assert.True(t, filepath.IsAbs(storage.Path))
-		expected, err := filepath.Abs(c.expectedPath)
-		assert.NoError(t, err)
-		actual, err := filepath.Abs(storage.Path)
-		assert.NoError(t, err)
-		assert.EqualValues(t, expected, actual)
+		assert.EqualValues(t, filepath.Clean(c.expectedPath), filepath.Clean(storage.Path))
 	}
 }
 

From 1ecf9843db755172e4a601beb396f280e15962f0 Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Thu, 3 Aug 2023 12:34:28 +0800
Subject: [PATCH 15/16] Use storage's PATH as relative path's parent

---
 modules/setting/storage.go      | 16 +++++++++++-----
 modules/setting/storage_test.go |  2 +-
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/modules/setting/storage.go b/modules/setting/storage.go
index 24dde3196fe67..9952cc3803a91 100644
--- a/modules/setting/storage.go
+++ b/modules/setting/storage.go
@@ -92,6 +92,7 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 	}
 
 	var targetSec ConfigSection
+	// check typ first
 	if typ != "" {
 		var err error
 		targetSec, err = rootCfg.GetSection(storageSectionName + "." + typ)
@@ -113,13 +114,17 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 		}
 	}
 
-	storageNameSec, _ := rootCfg.GetSection(storageSectionName + "." + name)
-
-	if targetSec == nil {
-		targetSec = sec
+	if targetSec == nil && sec != nil {
+		secTyp := sec.Key("STORAGE_TYPE").String()
+		if IsValidStorageType(StorageType(secTyp)) {
+			targetSec = sec
+		} else if secTyp != "" {
+			targetSec, _ = rootCfg.GetSection(storageSectionName + "." + secTyp)
+		}
 	}
 
 	targetSecIsStoragename := false
+	storageNameSec, _ := rootCfg.GetSection(storageSectionName + "." + name)
 	if targetSec == nil {
 		targetSec = storageNameSec
 		targetSecIsStoragename = storageNameSec != nil
@@ -196,8 +201,9 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 			storage.Path = fallbackPath
 		} else {
 			storage.Path = ConfigSectionKeyString(extraConfigSec, "PATH", fallbackPath)
+			fmt.Println("----", targetSec.Name(), targetPath, fallbackPath, storage.Path)
 			if !filepath.IsAbs(storage.Path) {
-				storage.Path = filepath.Join(AppDataPath, storage.Path)
+				storage.Path = filepath.Join(targetPath, storage.Path)
 			}
 		}
 
diff --git a/modules/setting/storage_test.go b/modules/setting/storage_test.go
index 7a6b31d9b9580..9a83f31d918b4 100644
--- a/modules/setting/storage_test.go
+++ b/modules/setting/storage_test.go
@@ -196,7 +196,7 @@ PATH = /data/gitea
 PATH = the-archives-dir
 `, []testLocalStoragePathCase{
 		{loadPackagesFrom, &Packages.Storage, "/data/gitea/packages"},
-		{loadRepoArchiveFrom, &RepoArchive.Storage, "/appdata/the-archives-dir"},
+		{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"},

From d4e545c887ea2f8f886cfaf8bc3abf683cdfedae Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Thu, 3 Aug 2023 18:27:43 +0800
Subject: [PATCH 16/16] Fix lint

---
 modules/setting/storage.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/modules/setting/storage.go b/modules/setting/storage.go
index 9952cc3803a91..c28f2be4ed714 100644
--- a/modules/setting/storage.go
+++ b/modules/setting/storage.go
@@ -201,7 +201,6 @@ func getStorage(rootCfg ConfigProvider, name, typ string, sec ConfigSection) (*S
 			storage.Path = fallbackPath
 		} else {
 			storage.Path = ConfigSectionKeyString(extraConfigSec, "PATH", fallbackPath)
-			fmt.Println("----", targetSec.Name(), targetPath, fallbackPath, storage.Path)
 			if !filepath.IsAbs(storage.Path) {
 				storage.Path = filepath.Join(targetPath, storage.Path)
 			}