refactor: Implement dependency injection for handlers and services

- Refactored AuthHandler, UserHandler, TextureHandler, ProfileHandler, CaptchaHandler, and YggdrasilHandler to use dependency injection.
- Removed direct instantiation of services and repositories within handlers, replacing them with constructor injection.
- Updated the container to initialize service instances and provide them to handlers.
- Enhanced code structure for better testability and adherence to Go best practices.

internal/service/helpers_test.go

@@ -0,0 +1,50 @@
+package service
+
+import (
+	"errors"
+	"testing"
+)
+
+// TestNormalizePagination_Basic 覆盖 NormalizePagination 的边界分支
+func TestNormalizePagination_Basic(t *testing.T) {
+	tests := []struct {
+		name         string
+		page         int
+		size         int
+		wantPage     int
+		wantPageSize int
+	}{
+		{"page 小于 1", 0, 10, 1, 10},
+		{"pageSize 小于 1", 1, 0, 1, 20},
+		{"pageSize 大于 100", 2, 200, 2, 100},
+		{"正常范围", 3, 30, 3, 30},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotPage, gotSize := NormalizePagination(tt.page, tt.size)
+			if gotPage != tt.wantPage || gotSize != tt.wantPageSize {
+				t.Fatalf("NormalizePagination(%d,%d) = (%d,%d), want (%d,%d)",
+					tt.page, tt.size, gotPage, gotSize, tt.wantPage, tt.wantPageSize)
+			}
+		})
+	}
+}
+
+// TestWrapError 覆盖 WrapError 的 nil 与非 nil 分支
+func TestWrapError(t *testing.T) {
+	if err := WrapError(nil, "msg"); err != nil {
+		t.Fatalf("WrapError(nil, ...) 应返回 nil, got=%v", err)
+	}
+
+	orig := errors.New("orig")
+	wrapped := WrapError(orig, "context")
+	if wrapped == nil {
+		t.Fatalf("WrapError 应返回非 nil 错误")
+	}
+	if wrapped.Error() == orig.Error() {
+		t.Fatalf("WrapError 应添加上下文信息, got=%v", wrapped)
+	}
+}
+
+

internal/service/mocks_test.go

@@ -0,0 +1,964 @@
+package service
+
+import (
+	"carrotskin/internal/model"
+	"errors"
+)
+
+// ============================================================================
+// Repository Mocks
+// ============================================================================
+
+// MockUserRepository 模拟UserRepository
+type MockUserRepository struct {
+	users map[int64]*model.User
+	// 用于模拟错误的标志
+	FailCreate         bool
+	FailFindByID       bool
+	FailFindByUsername bool
+	FailFindByEmail    bool
+	FailUpdate         bool
+}
+
+func NewMockUserRepository() *MockUserRepository {
+	return &MockUserRepository{
+		users: make(map[int64]*model.User),
+	}
+}
+
+func (m *MockUserRepository) Create(user *model.User) error {
+	if m.FailCreate {
+		return errors.New("mock create error")
+	}
+	if user.ID == 0 {
+		user.ID = int64(len(m.users) + 1)
+	}
+	m.users[user.ID] = user
+	return nil
+}
+
+func (m *MockUserRepository) FindByID(id int64) (*model.User, error) {
+	if m.FailFindByID {
+		return nil, errors.New("mock find error")
+	}
+	if user, ok := m.users[id]; ok {
+		return user, nil
+	}
+	return nil, nil
+}
+
+func (m *MockUserRepository) FindByUsername(username string) (*model.User, error) {
+	if m.FailFindByUsername {
+		return nil, errors.New("mock find by username error")
+	}
+	for _, user := range m.users {
+		if user.Username == username {
+			return user, nil
+		}
+	}
+	return nil, nil
+}
+
+func (m *MockUserRepository) FindByEmail(email string) (*model.User, error) {
+	if m.FailFindByEmail {
+		return nil, errors.New("mock find by email error")
+	}
+	for _, user := range m.users {
+		if user.Email == email {
+			return user, nil
+		}
+	}
+	return nil, nil
+}
+
+func (m *MockUserRepository) Update(user *model.User) error {
+	if m.FailUpdate {
+		return errors.New("mock update error")
+	}
+	m.users[user.ID] = user
+	return nil
+}
+
+func (m *MockUserRepository) UpdateFields(id int64, fields map[string]interface{}) error {
+	if m.FailUpdate {
+		return errors.New("mock update fields error")
+	}
+	_, ok := m.users[id]
+	if !ok {
+		return errors.New("user not found")
+	}
+	return nil
+}
+
+func (m *MockUserRepository) Delete(id int64) error {
+	delete(m.users, id)
+	return nil
+}
+
+func (m *MockUserRepository) CreateLoginLog(log *model.UserLoginLog) error {
+	return nil
+}
+
+func (m *MockUserRepository) CreatePointLog(log *model.UserPointLog) error {
+	return nil
+}
+
+func (m *MockUserRepository) UpdatePoints(userID int64, amount int, changeType, reason string) error {
+	return nil
+}
+
+// MockProfileRepository 模拟ProfileRepository
+type MockProfileRepository struct {
+	profiles     map[string]*model.Profile
+	userProfiles map[int64][]*model.Profile
+	nextID       int64
+	FailCreate   bool
+	FailFind     bool
+	FailUpdate   bool
+	FailDelete   bool
+}
+
+func NewMockProfileRepository() *MockProfileRepository {
+	return &MockProfileRepository{
+		profiles:     make(map[string]*model.Profile),
+		userProfiles: make(map[int64][]*model.Profile),
+		nextID:       1,
+	}
+}
+
+func (m *MockProfileRepository) Create(profile *model.Profile) error {
+	if m.FailCreate {
+		return errors.New("mock create error")
+	}
+	m.profiles[profile.UUID] = profile
+	m.userProfiles[profile.UserID] = append(m.userProfiles[profile.UserID], profile)
+	return nil
+}
+
+func (m *MockProfileRepository) FindByUUID(uuid string) (*model.Profile, error) {
+	if m.FailFind {
+		return nil, errors.New("mock find error")
+	}
+	if profile, ok := m.profiles[uuid]; ok {
+		return profile, nil
+	}
+	return nil, errors.New("profile not found")
+}
+
+func (m *MockProfileRepository) FindByName(name string) (*model.Profile, error) {
+	if m.FailFind {
+		return nil, errors.New("mock find error")
+	}
+	for _, profile := range m.profiles {
+		if profile.Name == name {
+			return profile, nil
+		}
+	}
+	return nil, nil
+}
+
+func (m *MockProfileRepository) FindByUserID(userID int64) ([]*model.Profile, error) {
+	if m.FailFind {
+		return nil, errors.New("mock find error")
+	}
+	return m.userProfiles[userID], nil
+}
+
+func (m *MockProfileRepository) Update(profile *model.Profile) error {
+	if m.FailUpdate {
+		return errors.New("mock update error")
+	}
+	m.profiles[profile.UUID] = profile
+	return nil
+}
+
+func (m *MockProfileRepository) UpdateFields(uuid string, updates map[string]interface{}) error {
+	if m.FailUpdate {
+		return errors.New("mock update error")
+	}
+	return nil
+}
+
+func (m *MockProfileRepository) Delete(uuid string) error {
+	if m.FailDelete {
+		return errors.New("mock delete error")
+	}
+	delete(m.profiles, uuid)
+	return nil
+}
+
+func (m *MockProfileRepository) CountByUserID(userID int64) (int64, error) {
+	return int64(len(m.userProfiles[userID])), nil
+}
+
+func (m *MockProfileRepository) SetActive(uuid string, userID int64) error {
+	return nil
+}
+
+func (m *MockProfileRepository) UpdateLastUsedAt(uuid string) error {
+	return nil
+}
+
+func (m *MockProfileRepository) GetByNames(names []string) ([]*model.Profile, error) {
+	var result []*model.Profile
+	for _, name := range names {
+		for _, profile := range m.profiles {
+			if profile.Name == name {
+				result = append(result, profile)
+			}
+		}
+	}
+	return result, nil
+}
+
+func (m *MockProfileRepository) GetKeyPair(profileId string) (*model.KeyPair, error) {
+	return nil, nil
+}
+
+func (m *MockProfileRepository) UpdateKeyPair(profileId string, keyPair *model.KeyPair) error {
+	return nil
+}
+
+// MockTextureRepository 模拟TextureRepository
+type MockTextureRepository struct {
+	textures   map[int64]*model.Texture
+	favorites  map[int64]map[int64]bool // userID -> textureID -> favorited
+	nextID     int64
+	FailCreate bool
+	FailFind   bool
+	FailUpdate bool
+	FailDelete bool
+}
+
+func NewMockTextureRepository() *MockTextureRepository {
+	return &MockTextureRepository{
+		textures:  make(map[int64]*model.Texture),
+		favorites: make(map[int64]map[int64]bool),
+		nextID:    1,
+	}
+}
+
+func (m *MockTextureRepository) Create(texture *model.Texture) error {
+	if m.FailCreate {
+		return errors.New("mock create error")
+	}
+	if texture.ID == 0 {
+		texture.ID = m.nextID
+		m.nextID++
+	}
+	m.textures[texture.ID] = texture
+	return nil
+}
+
+func (m *MockTextureRepository) FindByID(id int64) (*model.Texture, error) {
+	if m.FailFind {
+		return nil, errors.New("mock find error")
+	}
+	if texture, ok := m.textures[id]; ok {
+		return texture, nil
+	}
+	return nil, errors.New("texture not found")
+}
+
+func (m *MockTextureRepository) FindByHash(hash string) (*model.Texture, error) {
+	if m.FailFind {
+		return nil, errors.New("mock find error")
+	}
+	for _, texture := range m.textures {
+		if texture.Hash == hash {
+			return texture, nil
+		}
+	}
+	return nil, nil
+}
+
+func (m *MockTextureRepository) FindByUploaderID(uploaderID int64, page, pageSize int) ([]*model.Texture, int64, error) {
+	if m.FailFind {
+		return nil, 0, errors.New("mock find error")
+	}
+	var result []*model.Texture
+	for _, texture := range m.textures {
+		if texture.UploaderID == uploaderID {
+			result = append(result, texture)
+		}
+	}
+	return result, int64(len(result)), nil
+}
+
+func (m *MockTextureRepository) Search(keyword string, textureType model.TextureType, publicOnly bool, page, pageSize int) ([]*model.Texture, int64, error) {
+	if m.FailFind {
+		return nil, 0, errors.New("mock find error")
+	}
+	var result []*model.Texture
+	for _, texture := range m.textures {
+		if publicOnly && !texture.IsPublic {
+			continue
+		}
+		result = append(result, texture)
+	}
+	return result, int64(len(result)), nil
+}
+
+func (m *MockTextureRepository) Update(texture *model.Texture) error {
+	if m.FailUpdate {
+		return errors.New("mock update error")
+	}
+	m.textures[texture.ID] = texture
+	return nil
+}
+
+func (m *MockTextureRepository) UpdateFields(id int64, fields map[string]interface{}) error {
+	if m.FailUpdate {
+		return errors.New("mock update error")
+	}
+	return nil
+}
+
+func (m *MockTextureRepository) Delete(id int64) error {
+	if m.FailDelete {
+		return errors.New("mock delete error")
+	}
+	delete(m.textures, id)
+	return nil
+}
+
+func (m *MockTextureRepository) IncrementDownloadCount(id int64) error {
+	if texture, ok := m.textures[id]; ok {
+		texture.DownloadCount++
+	}
+	return nil
+}
+
+func (m *MockTextureRepository) IncrementFavoriteCount(id int64) error {
+	if texture, ok := m.textures[id]; ok {
+		texture.FavoriteCount++
+	}
+	return nil
+}
+
+func (m *MockTextureRepository) DecrementFavoriteCount(id int64) error {
+	if texture, ok := m.textures[id]; ok && texture.FavoriteCount > 0 {
+		texture.FavoriteCount--
+	}
+	return nil
+}
+
+func (m *MockTextureRepository) CreateDownloadLog(log *model.TextureDownloadLog) error {
+	return nil
+}
+
+func (m *MockTextureRepository) IsFavorited(userID, textureID int64) (bool, error) {
+	if userFavs, ok := m.favorites[userID]; ok {
+		return userFavs[textureID], nil
+	}
+	return false, nil
+}
+
+func (m *MockTextureRepository) AddFavorite(userID, textureID int64) error {
+	if m.favorites[userID] == nil {
+		m.favorites[userID] = make(map[int64]bool)
+	}
+	m.favorites[userID][textureID] = true
+	return nil
+}
+
+func (m *MockTextureRepository) RemoveFavorite(userID, textureID int64) error {
+	if userFavs, ok := m.favorites[userID]; ok {
+		delete(userFavs, textureID)
+	}
+	return nil
+}
+
+func (m *MockTextureRepository) GetUserFavorites(userID int64, page, pageSize int) ([]*model.Texture, int64, error) {
+	var result []*model.Texture
+	if userFavs, ok := m.favorites[userID]; ok {
+		for textureID := range userFavs {
+			if texture, exists := m.textures[textureID]; exists {
+				result = append(result, texture)
+			}
+		}
+	}
+	return result, int64(len(result)), nil
+}
+
+func (m *MockTextureRepository) CountByUploaderID(uploaderID int64) (int64, error) {
+	var count int64
+	for _, texture := range m.textures {
+		if texture.UploaderID == uploaderID {
+			count++
+		}
+	}
+	return count, nil
+}
+
+// MockTokenRepository 模拟TokenRepository
+type MockTokenRepository struct {
+	tokens     map[string]*model.Token
+	userTokens map[int64][]*model.Token
+	FailCreate bool
+	FailFind   bool
+	FailDelete bool
+}
+
+func NewMockTokenRepository() *MockTokenRepository {
+	return &MockTokenRepository{
+		tokens:     make(map[string]*model.Token),
+		userTokens: make(map[int64][]*model.Token),
+	}
+}
+
+func (m *MockTokenRepository) Create(token *model.Token) error {
+	if m.FailCreate {
+		return errors.New("mock create error")
+	}
+	m.tokens[token.AccessToken] = token
+	m.userTokens[token.UserID] = append(m.userTokens[token.UserID], token)
+	return nil
+}
+
+func (m *MockTokenRepository) FindByAccessToken(accessToken string) (*model.Token, error) {
+	if m.FailFind {
+		return nil, errors.New("mock find error")
+	}
+	if token, ok := m.tokens[accessToken]; ok {
+		return token, nil
+	}
+	return nil, errors.New("token not found")
+}
+
+func (m *MockTokenRepository) GetByUserID(userId int64) ([]*model.Token, error) {
+	if m.FailFind {
+		return nil, errors.New("mock find error")
+	}
+	return m.userTokens[userId], nil
+}
+
+func (m *MockTokenRepository) GetUUIDByAccessToken(accessToken string) (string, error) {
+	if m.FailFind {
+		return "", errors.New("mock find error")
+	}
+	if token, ok := m.tokens[accessToken]; ok {
+		return token.ProfileId, nil
+	}
+	return "", errors.New("token not found")
+}
+
+func (m *MockTokenRepository) GetUserIDByAccessToken(accessToken string) (int64, error) {
+	if m.FailFind {
+		return 0, errors.New("mock find error")
+	}
+	if token, ok := m.tokens[accessToken]; ok {
+		return token.UserID, nil
+	}
+	return 0, errors.New("token not found")
+}
+
+func (m *MockTokenRepository) DeleteByAccessToken(accessToken string) error {
+	if m.FailDelete {
+		return errors.New("mock delete error")
+	}
+	delete(m.tokens, accessToken)
+	return nil
+}
+
+func (m *MockTokenRepository) DeleteByUserID(userId int64) error {
+	if m.FailDelete {
+		return errors.New("mock delete error")
+	}
+	for _, token := range m.userTokens[userId] {
+		delete(m.tokens, token.AccessToken)
+	}
+	m.userTokens[userId] = nil
+	return nil
+}
+
+func (m *MockTokenRepository) BatchDelete(accessTokens []string) (int64, error) {
+	if m.FailDelete {
+		return 0, errors.New("mock delete error")
+	}
+	var count int64
+	for _, accessToken := range accessTokens {
+		if _, ok := m.tokens[accessToken]; ok {
+			delete(m.tokens, accessToken)
+			count++
+		}
+	}
+	return count, nil
+}
+
+// MockSystemConfigRepository 模拟SystemConfigRepository
+type MockSystemConfigRepository struct {
+	configs map[string]*model.SystemConfig
+}
+
+func NewMockSystemConfigRepository() *MockSystemConfigRepository {
+	return &MockSystemConfigRepository{
+		configs: make(map[string]*model.SystemConfig),
+	}
+}
+
+func (m *MockSystemConfigRepository) GetByKey(key string) (*model.SystemConfig, error) {
+	if config, ok := m.configs[key]; ok {
+		return config, nil
+	}
+	return nil, nil
+}
+
+func (m *MockSystemConfigRepository) GetPublic() ([]model.SystemConfig, error) {
+	var result []model.SystemConfig
+	for _, v := range m.configs {
+		result = append(result, *v)
+	}
+	return result, nil
+}
+
+func (m *MockSystemConfigRepository) GetAll() ([]model.SystemConfig, error) {
+	var result []model.SystemConfig
+	for _, v := range m.configs {
+		result = append(result, *v)
+	}
+	return result, nil
+}
+
+func (m *MockSystemConfigRepository) Update(config *model.SystemConfig) error {
+	m.configs[config.Key] = config
+	return nil
+}
+
+func (m *MockSystemConfigRepository) UpdateValue(key, value string) error {
+	if config, ok := m.configs[key]; ok {
+		config.Value = value
+		return nil
+	}
+	return errors.New("config not found")
+}
+
+// ============================================================================
+// Service Mocks
+// ============================================================================
+
+// MockUserService 模拟UserService
+type MockUserService struct {
+	users              map[int64]*model.User
+	maxProfilesPerUser int
+	maxTexturesPerUser int
+	FailRegister       bool
+	FailLogin          bool
+	FailGetByID        bool
+	FailUpdate         bool
+}
+
+func NewMockUserService() *MockUserService {
+	return &MockUserService{
+		users:              make(map[int64]*model.User),
+		maxProfilesPerUser: 5,
+		maxTexturesPerUser: 50,
+	}
+}
+
+func (m *MockUserService) Register(username, password, email, avatar string) (*model.User, string, error) {
+	if m.FailRegister {
+		return nil, "", errors.New("mock register error")
+	}
+	user := &model.User{
+		ID:       int64(len(m.users) + 1),
+		Username: username,
+		Email:    email,
+		Avatar:   avatar,
+		Status:   1,
+	}
+	m.users[user.ID] = user
+	return user, "mock-token", nil
+}
+
+func (m *MockUserService) Login(usernameOrEmail, password, ipAddress, userAgent string) (*model.User, string, error) {
+	if m.FailLogin {
+		return nil, "", errors.New("mock login error")
+	}
+	for _, user := range m.users {
+		if user.Username == usernameOrEmail || user.Email == usernameOrEmail {
+			return user, "mock-token", nil
+		}
+	}
+	return nil, "", errors.New("user not found")
+}
+
+func (m *MockUserService) GetByID(id int64) (*model.User, error) {
+	if m.FailGetByID {
+		return nil, errors.New("mock get by id error")
+	}
+	if user, ok := m.users[id]; ok {
+		return user, nil
+	}
+	return nil, nil
+}
+
+func (m *MockUserService) GetByEmail(email string) (*model.User, error) {
+	for _, user := range m.users {
+		if user.Email == email {
+			return user, nil
+		}
+	}
+	return nil, nil
+}
+
+func (m *MockUserService) UpdateInfo(user *model.User) error {
+	if m.FailUpdate {
+		return errors.New("mock update error")
+	}
+	m.users[user.ID] = user
+	return nil
+}
+
+func (m *MockUserService) UpdateAvatar(userID int64, avatarURL string) error {
+	if m.FailUpdate {
+		return errors.New("mock update error")
+	}
+	if user, ok := m.users[userID]; ok {
+		user.Avatar = avatarURL
+	}
+	return nil
+}
+
+func (m *MockUserService) ChangePassword(userID int64, oldPassword, newPassword string) error {
+	return nil
+}
+
+func (m *MockUserService) ResetPassword(email, newPassword string) error {
+	return nil
+}
+
+func (m *MockUserService) ChangeEmail(userID int64, newEmail string) error {
+	if user, ok := m.users[userID]; ok {
+		user.Email = newEmail
+	}
+	return nil
+}
+
+func (m *MockUserService) ValidateAvatarURL(avatarURL string) error {
+	return nil
+}
+
+func (m *MockUserService) GetMaxProfilesPerUser() int {
+	return m.maxProfilesPerUser
+}
+
+func (m *MockUserService) GetMaxTexturesPerUser() int {
+	return m.maxTexturesPerUser
+}
+
+// MockProfileService 模拟ProfileService
+type MockProfileService struct {
+	profiles   map[string]*model.Profile
+	FailCreate bool
+	FailGet    bool
+	FailUpdate bool
+	FailDelete bool
+}
+
+func NewMockProfileService() *MockProfileService {
+	return &MockProfileService{
+		profiles: make(map[string]*model.Profile),
+	}
+}
+
+func (m *MockProfileService) Create(userID int64, name string) (*model.Profile, error) {
+	if m.FailCreate {
+		return nil, errors.New("mock create error")
+	}
+	profile := &model.Profile{
+		UUID:   "mock-uuid-" + name,
+		UserID: userID,
+		Name:   name,
+	}
+	m.profiles[profile.UUID] = profile
+	return profile, nil
+}
+
+func (m *MockProfileService) GetByUUID(uuid string) (*model.Profile, error) {
+	if m.FailGet {
+		return nil, errors.New("mock get error")
+	}
+	if profile, ok := m.profiles[uuid]; ok {
+		return profile, nil
+	}
+	return nil, errors.New("profile not found")
+}
+
+func (m *MockProfileService) GetByUserID(userID int64) ([]*model.Profile, error) {
+	if m.FailGet {
+		return nil, errors.New("mock get error")
+	}
+	var result []*model.Profile
+	for _, profile := range m.profiles {
+		if profile.UserID == userID {
+			result = append(result, profile)
+		}
+	}
+	return result, nil
+}
+
+func (m *MockProfileService) Update(uuid string, userID int64, name *string, skinID, capeID *int64) (*model.Profile, error) {
+	if m.FailUpdate {
+		return nil, errors.New("mock update error")
+	}
+	if profile, ok := m.profiles[uuid]; ok {
+		if name != nil {
+			profile.Name = *name
+		}
+		if skinID != nil {
+			profile.SkinID = skinID
+		}
+		if capeID != nil {
+			profile.CapeID = capeID
+		}
+		return profile, nil
+	}
+	return nil, errors.New("profile not found")
+}
+
+func (m *MockProfileService) Delete(uuid string, userID int64) error {
+	if m.FailDelete {
+		return errors.New("mock delete error")
+	}
+	delete(m.profiles, uuid)
+	return nil
+}
+
+func (m *MockProfileService) SetActive(uuid string, userID int64) error {
+	return nil
+}
+
+func (m *MockProfileService) CheckLimit(userID int64, maxProfiles int) error {
+	count := 0
+	for _, profile := range m.profiles {
+		if profile.UserID == userID {
+			count++
+		}
+	}
+	if count >= maxProfiles {
+		return errors.New("达到档案数量上限")
+	}
+	return nil
+}
+
+func (m *MockProfileService) GetByNames(names []string) ([]*model.Profile, error) {
+	var result []*model.Profile
+	for _, name := range names {
+		for _, profile := range m.profiles {
+			if profile.Name == name {
+				result = append(result, profile)
+			}
+		}
+	}
+	return result, nil
+}
+
+func (m *MockProfileService) GetByProfileName(name string) (*model.Profile, error) {
+	for _, profile := range m.profiles {
+		if profile.Name == name {
+			return profile, nil
+		}
+	}
+	return nil, errors.New("profile not found")
+}
+
+// MockTextureService 模拟TextureService
+type MockTextureService struct {
+	textures   map[int64]*model.Texture
+	nextID     int64
+	FailCreate bool
+	FailGet    bool
+	FailUpdate bool
+	FailDelete bool
+}
+
+func NewMockTextureService() *MockTextureService {
+	return &MockTextureService{
+		textures: make(map[int64]*model.Texture),
+		nextID:   1,
+	}
+}
+
+func (m *MockTextureService) Create(uploaderID int64, name, description, textureType, url, hash string, size int, isPublic, isSlim bool) (*model.Texture, error) {
+	if m.FailCreate {
+		return nil, errors.New("mock create error")
+	}
+	texture := &model.Texture{
+		ID:          m.nextID,
+		UploaderID:  uploaderID,
+		Name:        name,
+		Description: description,
+		URL:         url,
+		Hash:        hash,
+		Size:        size,
+		IsPublic:    isPublic,
+		IsSlim:      isSlim,
+	}
+	m.textures[texture.ID] = texture
+	m.nextID++
+	return texture, nil
+}
+
+func (m *MockTextureService) GetByID(id int64) (*model.Texture, error) {
+	if m.FailGet {
+		return nil, errors.New("mock get error")
+	}
+	if texture, ok := m.textures[id]; ok {
+		return texture, nil
+	}
+	return nil, errors.New("texture not found")
+}
+
+func (m *MockTextureService) GetByUserID(uploaderID int64, page, pageSize int) ([]*model.Texture, int64, error) {
+	if m.FailGet {
+		return nil, 0, errors.New("mock get error")
+	}
+	var result []*model.Texture
+	for _, texture := range m.textures {
+		if texture.UploaderID == uploaderID {
+			result = append(result, texture)
+		}
+	}
+	return result, int64(len(result)), nil
+}
+
+func (m *MockTextureService) Search(keyword string, textureType model.TextureType, publicOnly bool, page, pageSize int) ([]*model.Texture, int64, error) {
+	if m.FailGet {
+		return nil, 0, errors.New("mock get error")
+	}
+	var result []*model.Texture
+	for _, texture := range m.textures {
+		if publicOnly && !texture.IsPublic {
+			continue
+		}
+		result = append(result, texture)
+	}
+	return result, int64(len(result)), nil
+}
+
+func (m *MockTextureService) Update(textureID, uploaderID int64, name, description string, isPublic *bool) (*model.Texture, error) {
+	if m.FailUpdate {
+		return nil, errors.New("mock update error")
+	}
+	if texture, ok := m.textures[textureID]; ok {
+		if name != "" {
+			texture.Name = name
+		}
+		if description != "" {
+			texture.Description = description
+		}
+		if isPublic != nil {
+			texture.IsPublic = *isPublic
+		}
+		return texture, nil
+	}
+	return nil, errors.New("texture not found")
+}
+
+func (m *MockTextureService) Delete(textureID, uploaderID int64) error {
+	if m.FailDelete {
+		return errors.New("mock delete error")
+	}
+	delete(m.textures, textureID)
+	return nil
+}
+
+func (m *MockTextureService) ToggleFavorite(userID, textureID int64) (bool, error) {
+	return true, nil
+}
+
+func (m *MockTextureService) GetUserFavorites(userID int64, page, pageSize int) ([]*model.Texture, int64, error) {
+	return nil, 0, nil
+}
+
+func (m *MockTextureService) CheckUploadLimit(uploaderID int64, maxTextures int) error {
+	count := 0
+	for _, texture := range m.textures {
+		if texture.UploaderID == uploaderID {
+			count++
+		}
+	}
+	if count >= maxTextures {
+		return errors.New("达到材质数量上限")
+	}
+	return nil
+}
+
+// MockTokenService 模拟TokenService
+type MockTokenService struct {
+	tokens       map[string]*model.Token
+	FailCreate   bool
+	FailValidate bool
+	FailRefresh  bool
+}
+
+func NewMockTokenService() *MockTokenService {
+	return &MockTokenService{
+		tokens: make(map[string]*model.Token),
+	}
+}
+
+func (m *MockTokenService) Create(userID int64, uuid, clientToken string) (*model.Profile, []*model.Profile, string, string, error) {
+	if m.FailCreate {
+		return nil, nil, "", "", errors.New("mock create error")
+	}
+	accessToken := "mock-access-token"
+	if clientToken == "" {
+		clientToken = "mock-client-token"
+	}
+	token := &model.Token{
+		AccessToken: accessToken,
+		ClientToken: clientToken,
+		UserID:      userID,
+		ProfileId:   uuid,
+		Usable:      true,
+	}
+	m.tokens[accessToken] = token
+	return nil, nil, accessToken, clientToken, nil
+}
+
+func (m *MockTokenService) Validate(accessToken, clientToken string) bool {
+	if m.FailValidate {
+		return false
+	}
+	if token, ok := m.tokens[accessToken]; ok {
+		if clientToken == "" || token.ClientToken == clientToken {
+			return token.Usable
+		}
+	}
+	return false
+}
+
+func (m *MockTokenService) Refresh(accessToken, clientToken, selectedProfileID string) (string, string, error) {
+	if m.FailRefresh {
+		return "", "", errors.New("mock refresh error")
+	}
+	return "new-access-token", clientToken, nil
+}
+
+func (m *MockTokenService) Invalidate(accessToken string) {
+	delete(m.tokens, accessToken)
+}
+
+func (m *MockTokenService) InvalidateUserTokens(userID int64) {
+	for key, token := range m.tokens {
+		if token.UserID == userID {
+			delete(m.tokens, key)
+		}
+	}
+}
+
+func (m *MockTokenService) GetUUIDByAccessToken(accessToken string) (string, error) {
+	if token, ok := m.tokens[accessToken]; ok {
+		return token.ProfileId, nil
+	}
+	return "", errors.New("token not found")
+}
+
+func (m *MockTokenService) GetUserIDByAccessToken(accessToken string) (int64, error) {
+	if token, ok := m.tokens[accessToken]; ok {
+		return token.UserID, nil
+	}
+	return 0, errors.New("token not found")
+}

internal/service/profile_service.go

@@ -11,35 +11,54 @@ import (
 	"fmt"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5"
+	"go.uber.org/zap"
 	"gorm.io/gorm"
 )
 
-// CreateProfile 创建档案
-func CreateProfile(db *gorm.DB, userID int64, name string) (*model.Profile, error) {
+// profileServiceImpl ProfileService的实现
+type profileServiceImpl struct {
+	profileRepo repository.ProfileRepository
+	userRepo    repository.UserRepository
+	logger      *zap.Logger
+}
+
+// NewProfileService 创建ProfileService实例
+func NewProfileService(
+	profileRepo repository.ProfileRepository,
+	userRepo repository.UserRepository,
+	logger *zap.Logger,
+) ProfileService {
+	return &profileServiceImpl{
+		profileRepo: profileRepo,
+		userRepo:    userRepo,
+		logger:      logger,
+	}
+}
+
+func (s *profileServiceImpl) Create(userID int64, name string) (*model.Profile, error) {
 	// 验证用户存在
-	user, err := EnsureUserExists(userID)
-	if err != nil {
-		return nil, err
+	user, err := s.userRepo.FindByID(userID)
+	if err != nil || user == nil {
+		return nil, errors.New("用户不存在")
 	}
 	if user.Status != 1 {
-		return nil, fmt.Errorf("用户状态异常")
+		return nil, errors.New("用户状态异常")
 	}
 
 	// 检查角色名是否已存在
-	existingName, err := repository.FindProfileByName(name)
+	existingName, err := s.profileRepo.FindByName(name)
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, WrapError(err, "查询角色名失败")
+		return nil, fmt.Errorf("查询角色名失败: %w", err)
 	}
 	if existingName != nil {
-		return nil, fmt.Errorf("角色名已被使用")
+		return nil, errors.New("角色名已被使用")
 	}
 
 	// 生成UUID和RSA密钥
 	profileUUID := uuid.New().String()
-	privateKey, err := generateRSAPrivateKey()
+	privateKey, err := generateRSAPrivateKeyInternal()
 	if err != nil {
-		return nil, WrapError(err, "生成RSA密钥失败")
+		return nil, fmt.Errorf("生成RSA密钥失败: %w", err)
 	}
 
 	// 创建档案
@@ -51,55 +70,59 @@ func CreateProfile(db *gorm.DB, userID int64, name string) (*model.Profile, erro
 		IsActive:      true,
 	}
 
-	if err := repository.CreateProfile(profile); err != nil {
-		return nil, WrapError(err, "创建档案失败")
+	if err := s.profileRepo.Create(profile); err != nil {
+		return nil, fmt.Errorf("创建档案失败: %w", err)
 	}
 
 	// 设置活跃状态
-	if err := repository.SetActiveProfile(profileUUID, userID); err != nil {
-		return nil, WrapError(err, "设置活跃状态失败")
+	if err := s.profileRepo.SetActive(profileUUID, userID); err != nil {
+		return nil, fmt.Errorf("设置活跃状态失败: %w", err)
 	}
 
 	return profile, nil
 }
 
-// GetProfileByUUID 获取档案详情
-func GetProfileByUUID(db *gorm.DB, uuid string) (*model.Profile, error) {
-	profile, err := repository.FindProfileByUUID(uuid)
+func (s *profileServiceImpl) GetByUUID(uuid string) (*model.Profile, error) {
+	profile, err := s.profileRepo.FindByUUID(uuid)
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, ErrProfileNotFound
 		}
-		return nil, WrapError(err, "查询档案失败")
+		return nil, fmt.Errorf("查询档案失败: %w", err)
 	}
 	return profile, nil
 }
 
-// GetUserProfiles 获取用户的所有档案
-func GetUserProfiles(db *gorm.DB, userID int64) ([]*model.Profile, error) {
-	profiles, err := repository.FindProfilesByUserID(userID)
+func (s *profileServiceImpl) GetByUserID(userID int64) ([]*model.Profile, error) {
+	profiles, err := s.profileRepo.FindByUserID(userID)
 	if err != nil {
-		return nil, WrapError(err, "查询档案列表失败")
+		return nil, fmt.Errorf("查询档案列表失败: %w", err)
 	}
 	return profiles, nil
 }
 
-// UpdateProfile 更新档案
-func UpdateProfile(db *gorm.DB, uuid string, userID int64, name *string, skinID, capeID *int64) (*model.Profile, error) {
+func (s *profileServiceImpl) Update(uuid string, userID int64, name *string, skinID, capeID *int64) (*model.Profile, error) {
 	// 获取档案并验证权限
-	profile, err := GetProfileWithPermissionCheck(uuid, userID)
+	profile, err := s.profileRepo.FindByUUID(uuid)
 	if err != nil {
-		return nil, err
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, ErrProfileNotFound
+		}
+		return nil, fmt.Errorf("查询档案失败: %w", err)
+	}
+
+	if profile.UserID != userID {
+		return nil, ErrProfileNoPermission
 	}
 
 	// 检查角色名是否重复
 	if name != nil && *name != profile.Name {
-		existingName, err := repository.FindProfileByName(*name)
+		existingName, err := s.profileRepo.FindByName(*name)
 		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, WrapError(err, "查询角色名失败")
+			return nil, fmt.Errorf("查询角色名失败: %w", err)
 		}
 		if existingName != nil {
-			return nil, fmt.Errorf("角色名已被使用")
+			return nil, errors.New("角色名已被使用")
 		}
 		profile.Name = *name
 	}
@@ -112,47 +135,62 @@ func UpdateProfile(db *gorm.DB, uuid string, userID int64, name *string, skinID,
 		profile.CapeID = capeID
 	}
 
-	if err := repository.UpdateProfile(profile); err != nil {
-		return nil, WrapError(err, "更新档案失败")
+	if err := s.profileRepo.Update(profile); err != nil {
+		return nil, fmt.Errorf("更新档案失败: %w", err)
 	}
 
-	return repository.FindProfileByUUID(uuid)
+	return s.profileRepo.FindByUUID(uuid)
 }
 
-// DeleteProfile 删除档案
-func DeleteProfile(db *gorm.DB, uuid string, userID int64) error {
-	if _, err := GetProfileWithPermissionCheck(uuid, userID); err != nil {
-		return err
-	}
-
-	if err := repository.DeleteProfile(uuid); err != nil {
-		return WrapError(err, "删除档案失败")
-	}
-	return nil
-}
-
-// SetActiveProfile 设置活跃档案
-func SetActiveProfile(db *gorm.DB, uuid string, userID int64) error {
-	if _, err := GetProfileWithPermissionCheck(uuid, userID); err != nil {
-		return err
-	}
-
-	if err := repository.SetActiveProfile(uuid, userID); err != nil {
-		return WrapError(err, "设置活跃状态失败")
-	}
-
-	if err := repository.UpdateProfileLastUsedAt(uuid); err != nil {
-		return WrapError(err, "更新使用时间失败")
-	}
-
-	return nil
-}
-
-// CheckProfileLimit 检查用户档案数量限制
-func CheckProfileLimit(db *gorm.DB, userID int64, maxProfiles int) error {
-	count, err := repository.CountProfilesByUserID(userID)
+func (s *profileServiceImpl) Delete(uuid string, userID int64) error {
+	// 获取档案并验证权限
+	profile, err := s.profileRepo.FindByUUID(uuid)
 	if err != nil {
-		return WrapError(err, "查询档案数量失败")
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return ErrProfileNotFound
+		}
+		return fmt.Errorf("查询档案失败: %w", err)
+	}
+
+	if profile.UserID != userID {
+		return ErrProfileNoPermission
+	}
+
+	if err := s.profileRepo.Delete(uuid); err != nil {
+		return fmt.Errorf("删除档案失败: %w", err)
+	}
+	return nil
+}
+
+func (s *profileServiceImpl) SetActive(uuid string, userID int64) error {
+	// 获取档案并验证权限
+	profile, err := s.profileRepo.FindByUUID(uuid)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return ErrProfileNotFound
+		}
+		return fmt.Errorf("查询档案失败: %w", err)
+	}
+
+	if profile.UserID != userID {
+		return ErrProfileNoPermission
+	}
+
+	if err := s.profileRepo.SetActive(uuid, userID); err != nil {
+		return fmt.Errorf("设置活跃状态失败: %w", err)
+	}
+
+	if err := s.profileRepo.UpdateLastUsedAt(uuid); err != nil {
+		return fmt.Errorf("更新使用时间失败: %w", err)
+	}
+
+	return nil
+}
+
+func (s *profileServiceImpl) CheckLimit(userID int64, maxProfiles int) error {
+	count, err := s.profileRepo.CountByUserID(userID)
+	if err != nil {
+		return fmt.Errorf("查询档案数量失败: %w", err)
 	}
 
 	if int(count) >= maxProfiles {
@@ -161,8 +199,24 @@ func CheckProfileLimit(db *gorm.DB, userID int64, maxProfiles int) error {
 	return nil
 }
 
-// generateRSAPrivateKey 生成RSA-2048私钥（PEM格式）
-func generateRSAPrivateKey() (string, error) {
+func (s *profileServiceImpl) GetByNames(names []string) ([]*model.Profile, error) {
+	profiles, err := s.profileRepo.GetByNames(names)
+	if err != nil {
+		return nil, fmt.Errorf("查找失败: %w", err)
+	}
+	return profiles, nil
+}
+
+func (s *profileServiceImpl) GetByProfileName(name string) (*model.Profile, error) {
+	profile, err := s.profileRepo.FindByName(name)
+	if err != nil {
+		return nil, errors.New("用户角色未创建")
+	}
+	return profile, nil
+}
+
+// generateRSAPrivateKeyInternal 生成RSA-2048私钥（PEM格式）
+func generateRSAPrivateKeyInternal() (string, error) {
 	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
 	if err != nil {
 		return "", err
@@ -177,33 +231,4 @@ func generateRSAPrivateKey() (string, error) {
 	return string(privateKeyPEM), nil
 }
 
-func ValidateProfileByUserID(db *gorm.DB, userId int64, UUID string) (bool, error) {
-	if userId == 0 || UUID == "" {
-		return false, errors.New("用户ID或配置文件ID不能为空")
-	}
 
-	profile, err := repository.FindProfileByUUID(UUID)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return false, errors.New("配置文件不存在")
-		}
-		return false, WrapError(err, "验证配置文件失败")
-	}
-	return profile.UserID == userId, nil
-}
-
-func GetProfilesDataByNames(db *gorm.DB, names []string) ([]*model.Profile, error) {
-	profiles, err := repository.GetProfilesByNames(names)
-	if err != nil {
-		return nil, WrapError(err, "查找失败")
-	}
-	return profiles, nil
-}
-
-func GetProfileKeyPair(db *gorm.DB, profileId string) (*model.KeyPair, error) {
-	keyPair, err := repository.GetProfileKeyPair(profileId)
-	if err != nil {
-		return nil, WrapError(err, "查找失败")
-	}
-	return keyPair, nil
-}

internal/service/profile_service_impl.go

@@ -1,234 +0,0 @@
-package service
-
-import (
-	"carrotskin/internal/model"
-	"carrotskin/internal/repository"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"encoding/pem"
-	"errors"
-	"fmt"
-
-	"github.com/google/uuid"
-	"go.uber.org/zap"
-	"gorm.io/gorm"
-)
-
-// profileServiceImpl ProfileService的实现
-type profileServiceImpl struct {
-	profileRepo repository.ProfileRepository
-	userRepo    repository.UserRepository
-	logger      *zap.Logger
-}
-
-// NewProfileService 创建ProfileService实例
-func NewProfileService(
-	profileRepo repository.ProfileRepository,
-	userRepo repository.UserRepository,
-	logger *zap.Logger,
-) ProfileService {
-	return &profileServiceImpl{
-		profileRepo: profileRepo,
-		userRepo:    userRepo,
-		logger:      logger,
-	}
-}
-
-func (s *profileServiceImpl) Create(userID int64, name string) (*model.Profile, error) {
-	// 验证用户存在
-	user, err := s.userRepo.FindByID(userID)
-	if err != nil || user == nil {
-		return nil, errors.New("用户不存在")
-	}
-	if user.Status != 1 {
-		return nil, errors.New("用户状态异常")
-	}
-
-	// 检查角色名是否已存在
-	existingName, err := s.profileRepo.FindByName(name)
-	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, fmt.Errorf("查询角色名失败: %w", err)
-	}
-	if existingName != nil {
-		return nil, errors.New("角色名已被使用")
-	}
-
-	// 生成UUID和RSA密钥
-	profileUUID := uuid.New().String()
-	privateKey, err := generateRSAPrivateKeyInternal()
-	if err != nil {
-		return nil, fmt.Errorf("生成RSA密钥失败: %w", err)
-	}
-
-	// 创建档案
-	profile := &model.Profile{
-		UUID:          profileUUID,
-		UserID:        userID,
-		Name:          name,
-		RSAPrivateKey: privateKey,
-		IsActive:      true,
-	}
-
-	if err := s.profileRepo.Create(profile); err != nil {
-		return nil, fmt.Errorf("创建档案失败: %w", err)
-	}
-
-	// 设置活跃状态
-	if err := s.profileRepo.SetActive(profileUUID, userID); err != nil {
-		return nil, fmt.Errorf("设置活跃状态失败: %w", err)
-	}
-
-	return profile, nil
-}
-
-func (s *profileServiceImpl) GetByUUID(uuid string) (*model.Profile, error) {
-	profile, err := s.profileRepo.FindByUUID(uuid)
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, ErrProfileNotFound
-		}
-		return nil, fmt.Errorf("查询档案失败: %w", err)
-	}
-	return profile, nil
-}
-
-func (s *profileServiceImpl) GetByUserID(userID int64) ([]*model.Profile, error) {
-	profiles, err := s.profileRepo.FindByUserID(userID)
-	if err != nil {
-		return nil, fmt.Errorf("查询档案列表失败: %w", err)
-	}
-	return profiles, nil
-}
-
-func (s *profileServiceImpl) Update(uuid string, userID int64, name *string, skinID, capeID *int64) (*model.Profile, error) {
-	// 获取档案并验证权限
-	profile, err := s.profileRepo.FindByUUID(uuid)
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, ErrProfileNotFound
-		}
-		return nil, fmt.Errorf("查询档案失败: %w", err)
-	}
-
-	if profile.UserID != userID {
-		return nil, ErrProfileNoPermission
-	}
-
-	// 检查角色名是否重复
-	if name != nil && *name != profile.Name {
-		existingName, err := s.profileRepo.FindByName(*name)
-		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, fmt.Errorf("查询角色名失败: %w", err)
-		}
-		if existingName != nil {
-			return nil, errors.New("角色名已被使用")
-		}
-		profile.Name = *name
-	}
-
-	// 更新皮肤和披风
-	if skinID != nil {
-		profile.SkinID = skinID
-	}
-	if capeID != nil {
-		profile.CapeID = capeID
-	}
-
-	if err := s.profileRepo.Update(profile); err != nil {
-		return nil, fmt.Errorf("更新档案失败: %w", err)
-	}
-
-	return s.profileRepo.FindByUUID(uuid)
-}
-
-func (s *profileServiceImpl) Delete(uuid string, userID int64) error {
-	// 获取档案并验证权限
-	profile, err := s.profileRepo.FindByUUID(uuid)
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return ErrProfileNotFound
-		}
-		return fmt.Errorf("查询档案失败: %w", err)
-	}
-
-	if profile.UserID != userID {
-		return ErrProfileNoPermission
-	}
-
-	if err := s.profileRepo.Delete(uuid); err != nil {
-		return fmt.Errorf("删除档案失败: %w", err)
-	}
-	return nil
-}
-
-func (s *profileServiceImpl) SetActive(uuid string, userID int64) error {
-	// 获取档案并验证权限
-	profile, err := s.profileRepo.FindByUUID(uuid)
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return ErrProfileNotFound
-		}
-		return fmt.Errorf("查询档案失败: %w", err)
-	}
-
-	if profile.UserID != userID {
-		return ErrProfileNoPermission
-	}
-
-	if err := s.profileRepo.SetActive(uuid, userID); err != nil {
-		return fmt.Errorf("设置活跃状态失败: %w", err)
-	}
-
-	if err := s.profileRepo.UpdateLastUsedAt(uuid); err != nil {
-		return fmt.Errorf("更新使用时间失败: %w", err)
-	}
-
-	return nil
-}
-
-func (s *profileServiceImpl) CheckLimit(userID int64, maxProfiles int) error {
-	count, err := s.profileRepo.CountByUserID(userID)
-	if err != nil {
-		return fmt.Errorf("查询档案数量失败: %w", err)
-	}
-
-	if int(count) >= maxProfiles {
-		return fmt.Errorf("已达到档案数量上限（%d个）", maxProfiles)
-	}
-	return nil
-}
-
-func (s *profileServiceImpl) GetByNames(names []string) ([]*model.Profile, error) {
-	profiles, err := s.profileRepo.GetByNames(names)
-	if err != nil {
-		return nil, fmt.Errorf("查找失败: %w", err)
-	}
-	return profiles, nil
-}
-
-func (s *profileServiceImpl) GetByProfileName(name string) (*model.Profile, error) {
-	profile, err := s.profileRepo.FindByName(name)
-	if err != nil {
-		return nil, errors.New("用户角色未创建")
-	}
-	return profile, nil
-}
-
-// generateRSAPrivateKeyInternal 生成RSA-2048私钥（PEM格式）
-func generateRSAPrivateKeyInternal() (string, error) {
-	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
-	if err != nil {
-		return "", err
-	}
-
-	privateKeyBytes := x509.MarshalPKCS1PrivateKey(privateKey)
-	privateKeyPEM := pem.EncodeToMemory(&pem.Block{
-		Type:  "RSA PRIVATE KEY",
-		Bytes: privateKeyBytes,
-	})
-
-	return string(privateKeyPEM), nil
-}
-
-

internal/service/profile_service_test.go

@@ -1,7 +1,10 @@
 package service
 
 import (
+	"carrotskin/internal/model"
 	"testing"
+
+	"go.uber.org/zap"
 )
 
 // TestProfileService_Validation 测试Profile服务验证逻辑
@@ -347,22 +350,22 @@ func TestGenerateRSAPrivateKey(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			privateKey, err := generateRSAPrivateKey()
+			privateKey, err := generateRSAPrivateKeyInternal()
 			if (err != nil) != tt.wantError {
-				t.Errorf("generateRSAPrivateKey() error = %v, wantError %v", err, tt.wantError)
+				t.Errorf("generateRSAPrivateKeyInternal() error = %v, wantError %v", err, tt.wantError)
 				return
 			}
 			if !tt.wantError {
 				if privateKey == "" {
-					t.Error("generateRSAPrivateKey() 返回的私钥不应为空")
+					t.Error("generateRSAPrivateKeyInternal() 返回的私钥不应为空")
 				}
 				// 验证PEM格式
 				if len(privateKey) < 100 {
-					t.Errorf("generateRSAPrivateKey() 返回的私钥长度异常: %d", len(privateKey))
+					t.Errorf("generateRSAPrivateKeyInternal() 返回的私钥长度异常: %d", len(privateKey))
 				}
 				// 验证包含PEM头部
 				if !contains(privateKey, "BEGIN RSA PRIVATE KEY") {
-					t.Error("generateRSAPrivateKey() 返回的私钥应包含PEM头部")
+					t.Error("generateRSAPrivateKeyInternal() 返回的私钥应包含PEM头部")
 				}
 			}
 		})
@@ -373,9 +376,9 @@ func TestGenerateRSAPrivateKey(t *testing.T) {
 func TestGenerateRSAPrivateKey_Uniqueness(t *testing.T) {
 	keys := make(map[string]bool)
 	for i := 0; i < 10; i++ {
-		key, err := generateRSAPrivateKey()
+		key, err := generateRSAPrivateKeyInternal()
 		if err != nil {
-			t.Fatalf("generateRSAPrivateKey() 失败: %v", err)
+			t.Fatalf("generateRSAPrivateKeyInternal() 失败: %v", err)
 		}
 		if keys[key] {
 			t.Errorf("第%d次生成的密钥与之前重复", i+1)
@@ -404,3 +407,319 @@ func containsMiddle(s, substr string) bool {
 	}
 	return false
 }
+
+// ============================================================================
+// 使用 Mock 的集成测试
+// ============================================================================
+
+// TestProfileServiceImpl_Create 测试创建Profile
+func TestProfileServiceImpl_Create(t *testing.T) {
+	profileRepo := NewMockProfileRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	// 预置用户
+	testUser := &model.User{
+		ID:       1,
+		Username: "testuser",
+		Email:    "test@example.com",
+		Status:   1,
+	}
+	userRepo.Create(testUser)
+
+	profileService := NewProfileService(profileRepo, userRepo, logger)
+
+	tests := []struct {
+		name        string
+		userID      int64
+		profileName string
+		wantErr     bool
+		errMsg      string
+		setupMocks  func()
+	}{
+		{
+			name:        "正常创建Profile",
+			userID:      1,
+			profileName: "TestProfile",
+			wantErr:     false,
+		},
+		{
+			name:        "用户不存在",
+			userID:      999,
+			profileName: "TestProfile2",
+			wantErr:     true,
+			errMsg:      "用户不存在",
+		},
+		{
+			name:        "角色名已存在",
+			userID:      1,
+			profileName: "ExistingProfile",
+			wantErr:     true,
+			errMsg:      "角色名已被使用",
+			setupMocks: func() {
+				profileRepo.Create(&model.Profile{
+					UUID:   "existing-uuid",
+					UserID: 2,
+					Name:   "ExistingProfile",
+				})
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.setupMocks != nil {
+				tt.setupMocks()
+			}
+
+			profile, err := profileService.Create(tt.userID, tt.profileName)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Error("期望返回错误，但实际没有错误")
+					return
+				}
+				if tt.errMsg != "" && err.Error() != tt.errMsg {
+					t.Errorf("错误信息不匹配: got %v, want %v", err.Error(), tt.errMsg)
+				}
+			} else {
+				if err != nil {
+					t.Errorf("不期望返回错误: %v", err)
+					return
+				}
+				if profile == nil {
+					t.Error("返回的Profile不应为nil")
+				}
+				if profile.Name != tt.profileName {
+					t.Errorf("Profile名称不匹配: got %v, want %v", profile.Name, tt.profileName)
+				}
+				if profile.UUID == "" {
+					t.Error("Profile UUID不应为空")
+				}
+			}
+		})
+	}
+}
+
+// TestProfileServiceImpl_GetByUUID 测试获取Profile
+func TestProfileServiceImpl_GetByUUID(t *testing.T) {
+	profileRepo := NewMockProfileRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	// 预置Profile
+	testProfile := &model.Profile{
+		UUID:   "test-uuid-123",
+		UserID: 1,
+		Name:   "TestProfile",
+	}
+	profileRepo.Create(testProfile)
+
+	profileService := NewProfileService(profileRepo, userRepo, logger)
+
+	tests := []struct {
+		name    string
+		uuid    string
+		wantErr bool
+	}{
+		{
+			name:    "获取存在的Profile",
+			uuid:    "test-uuid-123",
+			wantErr: false,
+		},
+		{
+			name:    "获取不存在的Profile",
+			uuid:    "non-existent-uuid",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			profile, err := profileService.GetByUUID(tt.uuid)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Error("期望返回错误，但实际没有错误")
+				}
+			} else {
+				if err != nil {
+					t.Errorf("不期望返回错误: %v", err)
+					return
+				}
+				if profile == nil {
+					t.Error("返回的Profile不应为nil")
+				}
+				if profile.UUID != tt.uuid {
+					t.Errorf("Profile UUID不匹配: got %v, want %v", profile.UUID, tt.uuid)
+				}
+			}
+		})
+	}
+}
+
+// TestProfileServiceImpl_Delete 测试删除Profile
+func TestProfileServiceImpl_Delete(t *testing.T) {
+	profileRepo := NewMockProfileRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	// 预置Profile
+	testProfile := &model.Profile{
+		UUID:   "delete-test-uuid",
+		UserID: 1,
+		Name:   "DeleteTestProfile",
+	}
+	profileRepo.Create(testProfile)
+
+	profileService := NewProfileService(profileRepo, userRepo, logger)
+
+	tests := []struct {
+		name    string
+		uuid    string
+		userID  int64
+		wantErr bool
+	}{
+		{
+			name:    "正常删除",
+			uuid:    "delete-test-uuid",
+			userID:  1,
+			wantErr: false,
+		},
+		{
+			name:    "用户ID不匹配",
+			uuid:    "delete-test-uuid",
+			userID:  2,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := profileService.Delete(tt.uuid, tt.userID)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Error("期望返回错误，但实际没有错误")
+				}
+			} else {
+				if err != nil {
+					t.Errorf("不期望返回错误: %v", err)
+				}
+			}
+		})
+	}
+}
+
+// TestProfileServiceImpl_GetByUserID 测试按用户获取档案列表
+func TestProfileServiceImpl_GetByUserID(t *testing.T) {
+	profileRepo := NewMockProfileRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	// 为用户 1 和 2 预置不同档案
+	profileRepo.Create(&model.Profile{UUID: "p1", UserID: 1, Name: "P1"})
+	profileRepo.Create(&model.Profile{UUID: "p2", UserID: 1, Name: "P2"})
+	profileRepo.Create(&model.Profile{UUID: "p3", UserID: 2, Name: "P3"})
+
+	svc := NewProfileService(profileRepo, userRepo, logger)
+
+	list, err := svc.GetByUserID(1)
+	if err != nil {
+		t.Fatalf("GetByUserID 失败: %v", err)
+	}
+	if len(list) != 2 {
+		t.Fatalf("GetByUserID 返回数量错误, got=%d, want=2", len(list))
+	}
+}
+
+// TestProfileServiceImpl_Update_And_SetActive 测试 Update 与 SetActive
+func TestProfileServiceImpl_Update_And_SetActive(t *testing.T) {
+	profileRepo := NewMockProfileRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	profile := &model.Profile{
+		UUID:   "u1",
+		UserID: 1,
+		Name:   "OldName",
+	}
+	profileRepo.Create(profile)
+
+	svc := NewProfileService(profileRepo, userRepo, logger)
+
+	// 正常更新名称与皮肤/披风
+	newName := "NewName"
+	var skinID int64 = 10
+	var capeID int64 = 20
+	updated, err := svc.Update("u1", 1, &newName, &skinID, &capeID)
+	if err != nil {
+		t.Fatalf("Update 正常情况失败: %v", err)
+	}
+	if updated == nil || updated.Name != newName {
+		t.Fatalf("Update 未更新名称, got=%+v", updated)
+	}
+
+	// 用户无权限
+	if _, err := svc.Update("u1", 2, &newName, nil, nil); err == nil {
+		t.Fatalf("Update 在无权限时应返回错误")
+	}
+
+	// 名称重复
+	profileRepo.Create(&model.Profile{
+		UUID:   "u2",
+		UserID: 2,
+		Name:   "Duplicate",
+	})
+	if _, err := svc.Update("u1", 1, stringPtr("Duplicate"), nil, nil); err == nil {
+		t.Fatalf("Update 在名称重复时应返回错误")
+	}
+
+	// SetActive 正常
+	if err := svc.SetActive("u1", 1); err != nil {
+		t.Fatalf("SetActive 正常情况失败: %v", err)
+	}
+
+	// SetActive 无权限
+	if err := svc.SetActive("u1", 2); err == nil {
+		t.Fatalf("SetActive 在无权限时应返回错误")
+	}
+}
+
+// TestProfileServiceImpl_CheckLimit_And_GetByNames 测试 CheckLimit / GetByNames / GetByProfileName
+func TestProfileServiceImpl_CheckLimit_And_GetByNames(t *testing.T) {
+	profileRepo := NewMockProfileRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	// 为用户 1 预置 2 个档案
+	profileRepo.Create(&model.Profile{UUID: "a", UserID: 1, Name: "A"})
+	profileRepo.Create(&model.Profile{UUID: "b", UserID: 1, Name: "B"})
+
+	svc := NewProfileService(profileRepo, userRepo, logger)
+
+	// CheckLimit 未达上限
+	if err := svc.CheckLimit(1, 3); err != nil {
+		t.Fatalf("CheckLimit 未达到上限时不应报错: %v", err)
+	}
+
+	// CheckLimit 达到上限
+	if err := svc.CheckLimit(1, 2); err == nil {
+		t.Fatalf("CheckLimit 达到上限时应报错")
+	}
+
+	// GetByNames
+	list, err := svc.GetByNames([]string{"A", "B"})
+	if err != nil {
+		t.Fatalf("GetByNames 失败: %v", err)
+	}
+	if len(list) != 2 {
+		t.Fatalf("GetByNames 返回数量错误, got=%d, want=2", len(list))
+	}
+
+	// GetByProfileName 存在
+	p, err := svc.GetByProfileName("A")
+	if err != nil || p == nil || p.Name != "A" {
+		t.Fatalf("GetByProfileName 返回错误, profile=%+v, err=%v", p, err)
+	}
+}

internal/service/serialize_service.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"carrotskin/internal/model"
+	"carrotskin/internal/repository"
 	"carrotskin/pkg/redis"
 	"encoding/base64"
 	"time"
@@ -31,7 +32,7 @@ func SerializeProfile(db *gorm.DB, logger *zap.Logger, redisClient *redis.Client
 
 	// 处理皮肤
 	if p.SkinID != nil {
-		skin, err := GetTextureByID(db, *p.SkinID)
+		skin, err := repository.FindTextureByID(*p.SkinID)
 		if err != nil {
 			logger.Error("[ERROR] 获取皮肤失败:", zap.Error(err), zap.Any("SkinID:", *p.SkinID))
 		} else {
@@ -44,7 +45,7 @@ func SerializeProfile(db *gorm.DB, logger *zap.Logger, redisClient *redis.Client
 
 	// 处理披风
 	if p.CapeID != nil {
-		cape, err := GetTextureByID(db, *p.CapeID)
+		cape, err := repository.FindTextureByID(*p.CapeID)
 		if err != nil {
 			logger.Error("[ERROR] 获取披风失败:", zap.Error(err), zap.Any("capeID:", *p.CapeID))
 		} else {

internal/service/serialize_service_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"go.uber.org/zap/zaptest"
+	"gorm.io/datatypes"
 )
 
 // TestSerializeUser_NilUser 实际调用SerializeUser函数测试nil用户
@@ -19,25 +20,51 @@ func TestSerializeUser_NilUser(t *testing.T) {
 // TestSerializeUser_ActualCall 实际调用SerializeUser函数
 func TestSerializeUser_ActualCall(t *testing.T) {
 	logger := zaptest.NewLogger(t)
-	user := &model.User{
-		ID:       1,
-		Username: "testuser",
-		Email:    "test@example.com",
-		// Properties 使用 datatypes.JSON，测试中可以为空
-	}
 
-	result := SerializeUser(logger, user, "test-uuid-123")
-	if result == nil {
-		t.Fatal("SerializeUser() 返回的结果不应为nil")
-	}
+	t.Run("Properties为nil时", func(t *testing.T) {
+		user := &model.User{
+			ID:       1,
+			Username: "testuser",
+			Email:    "test@example.com",
+		}
 
-	if result["id"] != "test-uuid-123" {
-		t.Errorf("id = %v, want 'test-uuid-123'", result["id"])
-	}
+		result := SerializeUser(logger, user, "test-uuid-123")
+		if result == nil {
+			t.Fatal("SerializeUser() 返回的结果不应为nil")
+		}
 
-	if result["properties"] == nil {
-		t.Error("properties 不应为nil")
-	}
+		if result["id"] != "test-uuid-123" {
+			t.Errorf("id = %v, want 'test-uuid-123'", result["id"])
+		}
+
+		// 当 Properties 为 nil 时，properties 应该为 nil
+		if result["properties"] != nil {
+			t.Error("当 user.Properties 为 nil 时，properties 应为 nil")
+		}
+	})
+
+	t.Run("Properties有值时", func(t *testing.T) {
+		propsJSON := datatypes.JSON(`[{"name":"test","value":"value"}]`)
+		user := &model.User{
+			ID:         1,
+			Username:   "testuser",
+			Email:      "test@example.com",
+			Properties: &propsJSON,
+		}
+
+		result := SerializeUser(logger, user, "test-uuid-456")
+		if result == nil {
+			t.Fatal("SerializeUser() 返回的结果不应为nil")
+		}
+
+		if result["id"] != "test-uuid-456" {
+			t.Errorf("id = %v, want 'test-uuid-456'", result["id"])
+		}
+
+		if result["properties"] == nil {
+			t.Error("当 user.Properties 有值时，properties 不应为 nil")
+		}
+	})
 }
 
 // TestProperty_Structure 测试Property结构

internal/service/texture_service.go

@@ -6,18 +6,38 @@ import (
 	"errors"
 	"fmt"
 
-	"gorm.io/gorm"
+	"go.uber.org/zap"
 )
 
-// CreateTexture 创建材质
-func CreateTexture(db *gorm.DB, uploaderID int64, name, description, textureType, url, hash string, size int, isPublic, isSlim bool) (*model.Texture, error) {
+// textureServiceImpl TextureService的实现
+type textureServiceImpl struct {
+	textureRepo repository.TextureRepository
+	userRepo    repository.UserRepository
+	logger      *zap.Logger
+}
+
+// NewTextureService 创建TextureService实例
+func NewTextureService(
+	textureRepo repository.TextureRepository,
+	userRepo repository.UserRepository,
+	logger *zap.Logger,
+) TextureService {
+	return &textureServiceImpl{
+		textureRepo: textureRepo,
+		userRepo:    userRepo,
+		logger:      logger,
+	}
+}
+
+func (s *textureServiceImpl) Create(uploaderID int64, name, description, textureType, url, hash string, size int, isPublic, isSlim bool) (*model.Texture, error) {
 	// 验证用户存在
-	if _, err := EnsureUserExists(uploaderID); err != nil {
-		return nil, err
+	user, err := s.userRepo.FindByID(uploaderID)
+	if err != nil || user == nil {
+		return nil, ErrUserNotFound
 	}
 
 	// 检查Hash是否已存在
-	existingTexture, err := repository.FindTextureByHash(hash)
+	existingTexture, err := s.textureRepo.FindByHash(hash)
 	if err != nil {
 		return nil, err
 	}
@@ -26,7 +46,7 @@ func CreateTexture(db *gorm.DB, uploaderID int64, name, description, textureType
 	}
 
 	// 转换材质类型
-	textureTypeEnum, err := parseTextureType(textureType)
+	textureTypeEnum, err := parseTextureTypeInternal(textureType)
 	if err != nil {
 		return nil, err
 	}
@@ -47,36 +67,49 @@ func CreateTexture(db *gorm.DB, uploaderID int64, name, description, textureType
 		FavoriteCount: 0,
 	}
 
-	if err := repository.CreateTexture(texture); err != nil {
+	if err := s.textureRepo.Create(texture); err != nil {
 		return nil, err
 	}
 
 	return texture, nil
 }
 
-// GetTextureByID 根据ID获取材质
-func GetTextureByID(db *gorm.DB, id int64) (*model.Texture, error) {
-	return EnsureTextureExists(id)
-}
-
-// GetUserTextures 获取用户上传的材质列表
-func GetUserTextures(db *gorm.DB, uploaderID int64, page, pageSize int) ([]*model.Texture, int64, error) {
-	page, pageSize = NormalizePagination(page, pageSize)
-	return repository.FindTexturesByUploaderID(uploaderID, page, pageSize)
-}
-
-// SearchTextures 搜索材质
-func SearchTextures(db *gorm.DB, keyword string, textureType model.TextureType, publicOnly bool, page, pageSize int) ([]*model.Texture, int64, error) {
-	page, pageSize = NormalizePagination(page, pageSize)
-	return repository.SearchTextures(keyword, textureType, publicOnly, page, pageSize)
-}
-
-// UpdateTexture 更新材质
-func UpdateTexture(db *gorm.DB, textureID, uploaderID int64, name, description string, isPublic *bool) (*model.Texture, error) {
-	// 获取材质并验证权限
-	if _, err := GetTextureWithPermissionCheck(textureID, uploaderID); err != nil {
+func (s *textureServiceImpl) GetByID(id int64) (*model.Texture, error) {
+	texture, err := s.textureRepo.FindByID(id)
+	if err != nil {
 		return nil, err
 	}
+	if texture == nil {
+		return nil, ErrTextureNotFound
+	}
+	if texture.Status == -1 {
+		return nil, errors.New("材质已删除")
+	}
+	return texture, nil
+}
+
+func (s *textureServiceImpl) GetByUserID(uploaderID int64, page, pageSize int) ([]*model.Texture, int64, error) {
+	page, pageSize = NormalizePagination(page, pageSize)
+	return s.textureRepo.FindByUploaderID(uploaderID, page, pageSize)
+}
+
+func (s *textureServiceImpl) Search(keyword string, textureType model.TextureType, publicOnly bool, page, pageSize int) ([]*model.Texture, int64, error) {
+	page, pageSize = NormalizePagination(page, pageSize)
+	return s.textureRepo.Search(keyword, textureType, publicOnly, page, pageSize)
+}
+
+func (s *textureServiceImpl) Update(textureID, uploaderID int64, name, description string, isPublic *bool) (*model.Texture, error) {
+	// 获取材质并验证权限
+	texture, err := s.textureRepo.FindByID(textureID)
+	if err != nil {
+		return nil, err
+	}
+	if texture == nil {
+		return nil, ErrTextureNotFound
+	}
+	if texture.UploaderID != uploaderID {
+		return nil, ErrTextureNoPermission
+	}
 
 	// 更新字段
 	updates := make(map[string]interface{})
@@ -91,83 +124,73 @@ func UpdateTexture(db *gorm.DB, textureID, uploaderID int64, name, description s
 	}
 
 	if len(updates) > 0 {
-		if err := repository.UpdateTextureFields(textureID, updates); err != nil {
+		if err := s.textureRepo.UpdateFields(textureID, updates); err != nil {
 			return nil, err
 		}
 	}
 
-	return repository.FindTextureByID(textureID)
+	return s.textureRepo.FindByID(textureID)
 }
 
-// DeleteTexture 删除材质
-func DeleteTexture(db *gorm.DB, textureID, uploaderID int64) error {
-	if _, err := GetTextureWithPermissionCheck(textureID, uploaderID); err != nil {
+func (s *textureServiceImpl) Delete(textureID, uploaderID int64) error {
+	// 获取材质并验证权限
+	texture, err := s.textureRepo.FindByID(textureID)
+	if err != nil {
 		return err
 	}
-	return repository.DeleteTexture(textureID)
+	if texture == nil {
+		return ErrTextureNotFound
+	}
+	if texture.UploaderID != uploaderID {
+		return ErrTextureNoPermission
+	}
+
+	return s.textureRepo.Delete(textureID)
 }
 
-// RecordTextureDownload 记录下载
-func RecordTextureDownload(db *gorm.DB, textureID int64, userID *int64, ipAddress, userAgent string) error {
-	if _, err := EnsureTextureExists(textureID); err != nil {
-		return err
-	}
-
-	if err := repository.IncrementTextureDownloadCount(textureID); err != nil {
-		return err
-	}
-
-	log := &model.TextureDownloadLog{
-		TextureID: textureID,
-		UserID:    userID,
-		IPAddress: ipAddress,
-		UserAgent: userAgent,
-	}
-
-	return repository.CreateTextureDownloadLog(log)
-}
-
-// ToggleTextureFavorite 切换收藏状态
-func ToggleTextureFavorite(db *gorm.DB, userID, textureID int64) (bool, error) {
-	if _, err := EnsureTextureExists(textureID); err != nil {
+func (s *textureServiceImpl) ToggleFavorite(userID, textureID int64) (bool, error) {
+	// 确保材质存在
+	texture, err := s.textureRepo.FindByID(textureID)
+	if err != nil {
 		return false, err
 	}
+	if texture == nil {
+		return false, ErrTextureNotFound
+	}
 
-	isFavorited, err := repository.IsTextureFavorited(userID, textureID)
+	isFavorited, err := s.textureRepo.IsFavorited(userID, textureID)
 	if err != nil {
 		return false, err
 	}
 
 	if isFavorited {
 		// 已收藏 -> 取消收藏
-		if err := repository.RemoveTextureFavorite(userID, textureID); err != nil {
+		if err := s.textureRepo.RemoveFavorite(userID, textureID); err != nil {
 			return false, err
 		}
-		if err := repository.DecrementTextureFavoriteCount(textureID); err != nil {
+		if err := s.textureRepo.DecrementFavoriteCount(textureID); err != nil {
 			return false, err
 		}
 		return false, nil
-	} else {
-		// 未收藏 -> 添加收藏
-		if err := repository.AddTextureFavorite(userID, textureID); err != nil {
-			return false, err
-		}
-		if err := repository.IncrementTextureFavoriteCount(textureID); err != nil {
-			return false, err
-		}
-		return true, nil
 	}
+
+	// 未收藏 -> 添加收藏
+	if err := s.textureRepo.AddFavorite(userID, textureID); err != nil {
+		return false, err
+	}
+	if err := s.textureRepo.IncrementFavoriteCount(textureID); err != nil {
+		return false, err
+	}
+	return true, nil
 }
 
-// GetUserTextureFavorites 获取用户收藏的材质列表
-func GetUserTextureFavorites(db *gorm.DB, userID int64, page, pageSize int) ([]*model.Texture, int64, error) {
+func (s *textureServiceImpl) GetUserFavorites(userID int64, page, pageSize int) ([]*model.Texture, int64, error) {
 	page, pageSize = NormalizePagination(page, pageSize)
-	return repository.GetUserTextureFavorites(userID, page, pageSize)
+	return s.textureRepo.GetUserFavorites(userID, page, pageSize)
 }
 
-// CheckTextureUploadLimit 检查用户上传材质数量限制
-func CheckTextureUploadLimit(db *gorm.DB, uploaderID int64, maxTextures int) error {
-	count, err := repository.CountTexturesByUploaderID(uploaderID)
+func (s *textureServiceImpl) CheckUploadLimit(uploaderID int64, maxTextures int) error {
+	count, err := s.textureRepo.CountByUploaderID(uploaderID)
 	if err != nil {
 		return err
 	}
@@ -179,8 +202,8 @@ func CheckTextureUploadLimit(db *gorm.DB, uploaderID int64, maxTextures int) err
 	return nil
 }
 
-// parseTextureType 解析材质类型
-func parseTextureType(textureType string) (model.TextureType, error) {
+// parseTextureTypeInternal 解析材质类型
+func parseTextureTypeInternal(textureType string) (model.TextureType, error) {
 	switch textureType {
 	case "SKIN":
 		return model.TextureTypeSkin, nil

internal/service/texture_service_impl.go

@@ -1,215 +0,0 @@
-package service
-
-import (
-	"carrotskin/internal/model"
-	"carrotskin/internal/repository"
-	"errors"
-	"fmt"
-
-	"go.uber.org/zap"
-)
-
-// textureServiceImpl TextureService的实现
-type textureServiceImpl struct {
-	textureRepo repository.TextureRepository
-	userRepo    repository.UserRepository
-	logger      *zap.Logger
-}
-
-// NewTextureService 创建TextureService实例
-func NewTextureService(
-	textureRepo repository.TextureRepository,
-	userRepo repository.UserRepository,
-	logger *zap.Logger,
-) TextureService {
-	return &textureServiceImpl{
-		textureRepo: textureRepo,
-		userRepo:    userRepo,
-		logger:      logger,
-	}
-}
-
-func (s *textureServiceImpl) Create(uploaderID int64, name, description, textureType, url, hash string, size int, isPublic, isSlim bool) (*model.Texture, error) {
-	// 验证用户存在
-	user, err := s.userRepo.FindByID(uploaderID)
-	if err != nil || user == nil {
-		return nil, ErrUserNotFound
-	}
-
-	// 检查Hash是否已存在
-	existingTexture, err := s.textureRepo.FindByHash(hash)
-	if err != nil {
-		return nil, err
-	}
-	if existingTexture != nil {
-		return nil, errors.New("该材质已存在")
-	}
-
-	// 转换材质类型
-	textureTypeEnum, err := parseTextureTypeInternal(textureType)
-	if err != nil {
-		return nil, err
-	}
-
-	// 创建材质
-	texture := &model.Texture{
-		UploaderID:    uploaderID,
-		Name:          name,
-		Description:   description,
-		Type:          textureTypeEnum,
-		URL:           url,
-		Hash:          hash,
-		Size:          size,
-		IsPublic:      isPublic,
-		IsSlim:        isSlim,
-		Status:        1,
-		DownloadCount: 0,
-		FavoriteCount: 0,
-	}
-
-	if err := s.textureRepo.Create(texture); err != nil {
-		return nil, err
-	}
-
-	return texture, nil
-}
-
-func (s *textureServiceImpl) GetByID(id int64) (*model.Texture, error) {
-	texture, err := s.textureRepo.FindByID(id)
-	if err != nil {
-		return nil, err
-	}
-	if texture == nil {
-		return nil, ErrTextureNotFound
-	}
-	if texture.Status == -1 {
-		return nil, errors.New("材质已删除")
-	}
-	return texture, nil
-}
-
-func (s *textureServiceImpl) GetByUserID(uploaderID int64, page, pageSize int) ([]*model.Texture, int64, error) {
-	page, pageSize = NormalizePagination(page, pageSize)
-	return s.textureRepo.FindByUploaderID(uploaderID, page, pageSize)
-}
-
-func (s *textureServiceImpl) Search(keyword string, textureType model.TextureType, publicOnly bool, page, pageSize int) ([]*model.Texture, int64, error) {
-	page, pageSize = NormalizePagination(page, pageSize)
-	return s.textureRepo.Search(keyword, textureType, publicOnly, page, pageSize)
-}
-
-func (s *textureServiceImpl) Update(textureID, uploaderID int64, name, description string, isPublic *bool) (*model.Texture, error) {
-	// 获取材质并验证权限
-	texture, err := s.textureRepo.FindByID(textureID)
-	if err != nil {
-		return nil, err
-	}
-	if texture == nil {
-		return nil, ErrTextureNotFound
-	}
-	if texture.UploaderID != uploaderID {
-		return nil, ErrTextureNoPermission
-	}
-
-	// 更新字段
-	updates := make(map[string]interface{})
-	if name != "" {
-		updates["name"] = name
-	}
-	if description != "" {
-		updates["description"] = description
-	}
-	if isPublic != nil {
-		updates["is_public"] = *isPublic
-	}
-
-	if len(updates) > 0 {
-		if err := s.textureRepo.UpdateFields(textureID, updates); err != nil {
-			return nil, err
-		}
-	}
-
-	return s.textureRepo.FindByID(textureID)
-}
-
-func (s *textureServiceImpl) Delete(textureID, uploaderID int64) error {
-	// 获取材质并验证权限
-	texture, err := s.textureRepo.FindByID(textureID)
-	if err != nil {
-		return err
-	}
-	if texture == nil {
-		return ErrTextureNotFound
-	}
-	if texture.UploaderID != uploaderID {
-		return ErrTextureNoPermission
-	}
-
-	return s.textureRepo.Delete(textureID)
-}
-
-func (s *textureServiceImpl) ToggleFavorite(userID, textureID int64) (bool, error) {
-	// 确保材质存在
-	texture, err := s.textureRepo.FindByID(textureID)
-	if err != nil {
-		return false, err
-	}
-	if texture == nil {
-		return false, ErrTextureNotFound
-	}
-
-	isFavorited, err := s.textureRepo.IsFavorited(userID, textureID)
-	if err != nil {
-		return false, err
-	}
-
-	if isFavorited {
-		// 已收藏 -> 取消收藏
-		if err := s.textureRepo.RemoveFavorite(userID, textureID); err != nil {
-			return false, err
-		}
-		if err := s.textureRepo.DecrementFavoriteCount(textureID); err != nil {
-			return false, err
-		}
-		return false, nil
-	}
-
-	// 未收藏 -> 添加收藏
-	if err := s.textureRepo.AddFavorite(userID, textureID); err != nil {
-		return false, err
-	}
-	if err := s.textureRepo.IncrementFavoriteCount(textureID); err != nil {
-		return false, err
-	}
-	return true, nil
-}
-
-func (s *textureServiceImpl) GetUserFavorites(userID int64, page, pageSize int) ([]*model.Texture, int64, error) {
-	page, pageSize = NormalizePagination(page, pageSize)
-	return s.textureRepo.GetUserFavorites(userID, page, pageSize)
-}
-
-func (s *textureServiceImpl) CheckUploadLimit(uploaderID int64, maxTextures int) error {
-	count, err := s.textureRepo.CountByUploaderID(uploaderID)
-	if err != nil {
-		return err
-	}
-
-	if count >= int64(maxTextures) {
-		return fmt.Errorf("已达到最大上传数量限制(%d)", maxTextures)
-	}
-
-	return nil
-}
-
-// parseTextureTypeInternal 解析材质类型
-func parseTextureTypeInternal(textureType string) (model.TextureType, error) {
-	switch textureType {
-	case "SKIN":
-		return model.TextureTypeSkin, nil
-	case "CAPE":
-		return model.TextureTypeCape, nil
-	default:
-		return "", errors.New("无效的材质类型")
-	}
-}

internal/service/texture_service_test.go

@@ -1,7 +1,10 @@
 package service
 
 import (
+	"carrotskin/internal/model"
 	"testing"
+
+	"go.uber.org/zap"
 )
 
 // TestTextureService_TypeValidation 测试材质类型验证
@@ -469,3 +472,357 @@ func TestCheckTextureUploadLimit_Logic(t *testing.T) {
 func boolPtr(b bool) *bool {
 	return &b
 }
+
+// ============================================================================
+// 使用 Mock 的集成测试
+// ============================================================================
+
+// TestTextureServiceImpl_Create 测试创建Texture
+func TestTextureServiceImpl_Create(t *testing.T) {
+	textureRepo := NewMockTextureRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	// 预置用户
+	testUser := &model.User{
+		ID:       1,
+		Username: "testuser",
+		Email:    "test@example.com",
+		Status:   1,
+	}
+	userRepo.Create(testUser)
+
+	textureService := NewTextureService(textureRepo, userRepo, logger)
+
+	tests := []struct {
+		name        string
+		uploaderID  int64
+		textureName string
+		textureType string
+		hash        string
+		wantErr     bool
+		errContains string
+		setupMocks  func()
+	}{
+		{
+			name:        "正常创建SKIN材质",
+			uploaderID:  1,
+			textureName: "TestSkin",
+			textureType: "SKIN",
+			hash:        "unique-hash-1",
+			wantErr:     false,
+		},
+		{
+			name:        "正常创建CAPE材质",
+			uploaderID:  1,
+			textureName: "TestCape",
+			textureType: "CAPE",
+			hash:        "unique-hash-2",
+			wantErr:     false,
+		},
+		{
+			name:        "用户不存在",
+			uploaderID:  999,
+			textureName: "TestTexture",
+			textureType: "SKIN",
+			hash:        "unique-hash-3",
+			wantErr:     true,
+		},
+		{
+			name:        "材质Hash已存在",
+			uploaderID:  1,
+			textureName: "DuplicateTexture",
+			textureType: "SKIN",
+			hash:        "existing-hash",
+			wantErr:     true,
+			errContains: "已存在",
+			setupMocks: func() {
+				textureRepo.Create(&model.Texture{
+					ID:         100,
+					UploaderID: 1,
+					Name:       "ExistingTexture",
+					Hash:       "existing-hash",
+				})
+			},
+		},
+		{
+			name:        "无效的材质类型",
+			uploaderID:  1,
+			textureName: "InvalidTypeTexture",
+			textureType: "INVALID",
+			hash:        "unique-hash-4",
+			wantErr:     true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.setupMocks != nil {
+				tt.setupMocks()
+			}
+
+			texture, err := textureService.Create(
+				tt.uploaderID,
+				tt.textureName,
+				"Test description",
+				tt.textureType,
+				"http://example.com/texture.png",
+				tt.hash,
+				1024,
+				true,
+				false,
+			)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Error("期望返回错误，但实际没有错误")
+					return
+				}
+				if tt.errContains != "" && !containsString(err.Error(), tt.errContains) {
+					t.Errorf("错误信息应包含 %q, 实际为: %v", tt.errContains, err.Error())
+				}
+			} else {
+				if err != nil {
+					t.Errorf("不期望返回错误: %v", err)
+					return
+				}
+				if texture == nil {
+					t.Error("返回的Texture不应为nil")
+				}
+				if texture.Name != tt.textureName {
+					t.Errorf("Texture名称不匹配: got %v, want %v", texture.Name, tt.textureName)
+				}
+			}
+		})
+	}
+}
+
+// TestTextureServiceImpl_GetByID 测试获取Texture
+func TestTextureServiceImpl_GetByID(t *testing.T) {
+	textureRepo := NewMockTextureRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	// 预置Texture
+	testTexture := &model.Texture{
+		ID:         1,
+		UploaderID: 1,
+		Name:       "TestTexture",
+		Hash:       "test-hash",
+	}
+	textureRepo.Create(testTexture)
+
+	textureService := NewTextureService(textureRepo, userRepo, logger)
+
+	tests := []struct {
+		name    string
+		id      int64
+		wantErr bool
+	}{
+		{
+			name:    "获取存在的Texture",
+			id:      1,
+			wantErr: false,
+		},
+		{
+			name:    "获取不存在的Texture",
+			id:      999,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			texture, err := textureService.GetByID(tt.id)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Error("期望返回错误，但实际没有错误")
+				}
+			} else {
+				if err != nil {
+					t.Errorf("不期望返回错误: %v", err)
+					return
+				}
+				if texture == nil {
+					t.Error("返回的Texture不应为nil")
+				}
+			}
+		})
+	}
+}
+
+// TestTextureServiceImpl_GetByUserID_And_Search 测试 GetByUserID 与 Search 分页封装
+func TestTextureServiceImpl_GetByUserID_And_Search(t *testing.T) {
+	textureRepo := NewMockTextureRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	// 预置多条 Texture
+	for i := int64(1); i <= 5; i++ {
+		textureRepo.Create(&model.Texture{
+			ID:         i,
+			UploaderID: 1,
+			Name:       "T",
+			IsPublic:   i%2 == 0,
+		})
+	}
+
+	textureService := NewTextureService(textureRepo, userRepo, logger)
+
+	// GetByUserID 应按上传者过滤并调用 NormalizePagination
+	textures, total, err := textureService.GetByUserID(1, 0, 0)
+	if err != nil {
+		t.Fatalf("GetByUserID 失败: %v", err)
+	}
+	if total != int64(len(textures)) {
+		t.Fatalf("GetByUserID 返回数量与总数不一致, total=%d, len=%d", total, len(textures))
+	}
+
+	// Search 仅验证能够正常调用并返回结果
+	searchResult, searchTotal, err := textureService.Search("", "", true, -1, 200)
+	if err != nil {
+		t.Fatalf("Search 失败: %v", err)
+	}
+	if searchTotal != int64(len(searchResult)) {
+		t.Fatalf("Search 返回数量与总数不一致, total=%d, len=%d", searchTotal, len(searchResult))
+	}
+}
+
+// TestTextureServiceImpl_Update_And_Delete 测试 Update / Delete 权限与字段更新
+func TestTextureServiceImpl_Update_And_Delete(t *testing.T) {
+	textureRepo := NewMockTextureRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	texture := &model.Texture{
+		ID:         1,
+		UploaderID: 1,
+		Name:       "Old",
+		Description:"OldDesc",
+		IsPublic:   false,
+	}
+	textureRepo.Create(texture)
+
+	textureService := NewTextureService(textureRepo, userRepo, logger)
+
+	// 更新成功
+	newName := "NewName"
+	newDesc := "NewDesc"
+	public := boolPtr(true)
+	updated, err := textureService.Update(1, 1, newName, newDesc, public)
+	if err != nil {
+		t.Fatalf("Update 正常情况失败: %v", err)
+	}
+	// 由于 MockTextureRepository.UpdateFields 不会真正修改结构体字段，这里只验证不会返回 nil 即可
+	if updated == nil {
+		t.Fatalf("Update 返回结果不应为 nil")
+	}
+
+	// 无权限更新
+	if _, err := textureService.Update(1, 2, "X", "Y", nil); err == nil {
+		t.Fatalf("Update 在无权限时应返回错误")
+	}
+
+	// 删除成功
+	if err := textureService.Delete(1, 1); err != nil {
+		t.Fatalf("Delete 正常情况失败: %v", err)
+	}
+
+	// 无权限删除
+	if err := textureService.Delete(1, 2); err == nil {
+		t.Fatalf("Delete 在无权限时应返回错误")
+	}
+}
+
+// TestTextureServiceImpl_FavoritesAndLimit 测试 GetUserFavorites 与 CheckUploadLimit
+func TestTextureServiceImpl_FavoritesAndLimit(t *testing.T) {
+	textureRepo := NewMockTextureRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	// 预置若干 Texture 与收藏关系
+	for i := int64(1); i <= 3; i++ {
+		textureRepo.Create(&model.Texture{
+			ID:         i,
+			UploaderID: 1,
+			Name:       "T",
+		})
+		_ = textureRepo.AddFavorite(1, i)
+	}
+
+	textureService := NewTextureService(textureRepo, userRepo, logger)
+
+	// GetUserFavorites
+	favs, total, err := textureService.GetUserFavorites(1, -1, -1)
+	if err != nil {
+		t.Fatalf("GetUserFavorites 失败: %v", err)
+	}
+	if int64(len(favs)) != total || total != 3 {
+		t.Fatalf("GetUserFavorites 数量不正确, total=%d, len=%d", total, len(favs))
+	}
+
+	// CheckUploadLimit 未超过上限
+	if err := textureService.CheckUploadLimit(1, 10); err != nil {
+		t.Fatalf("CheckUploadLimit 在未达到上限时不应报错: %v", err)
+	}
+
+	// CheckUploadLimit 超过上限
+	if err := textureService.CheckUploadLimit(1, 2); err == nil {
+		t.Fatalf("CheckUploadLimit 在超过上限时应返回错误")
+	}
+}
+
+// TestTextureServiceImpl_ToggleFavorite 测试收藏功能
+func TestTextureServiceImpl_ToggleFavorite(t *testing.T) {
+	textureRepo := NewMockTextureRepository()
+	userRepo := NewMockUserRepository()
+	logger := zap.NewNop()
+
+	// 预置用户和Texture
+	testUser := &model.User{ID: 1, Username: "testuser", Status: 1}
+	userRepo.Create(testUser)
+
+	testTexture := &model.Texture{
+		ID:         1,
+		UploaderID: 1,
+		Name:       "TestTexture",
+		Hash:       "test-hash",
+	}
+	textureRepo.Create(testTexture)
+
+	textureService := NewTextureService(textureRepo, userRepo, logger)
+
+	// 第一次收藏
+	isFavorited, err := textureService.ToggleFavorite(1, 1)
+	if err != nil {
+		t.Errorf("第一次收藏失败: %v", err)
+	}
+	if !isFavorited {
+		t.Error("第一次操作应该是添加收藏")
+	}
+
+	// 第二次取消收藏
+	isFavorited, err = textureService.ToggleFavorite(1, 1)
+	if err != nil {
+		t.Errorf("取消收藏失败: %v", err)
+	}
+	if isFavorited {
+		t.Error("第二次操作应该是取消收藏")
+	}
+}
+
+// 辅助函数
+func containsString(s, substr string) bool {
+	return len(s) >= len(substr) && (s == substr ||
+		(len(s) > len(substr) && (findSubstring(s, substr) != -1)))
+}
+
+func findSubstring(s, substr string) int {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return i
+		}
+	}
+	return -1
+}

internal/service/token_service.go

@@ -6,35 +6,55 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5"
-	"go.uber.org/zap"
 	"strconv"
 	"time"
 
-	"gorm.io/gorm"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"go.uber.org/zap"
 )
 
-// 常量定义
+// tokenServiceImpl TokenService的实现
+type tokenServiceImpl struct {
+	tokenRepo   repository.TokenRepository
+	profileRepo repository.ProfileRepository
+	logger      *zap.Logger
+}
+
+// NewTokenService 创建TokenService实例
+func NewTokenService(
+	tokenRepo repository.TokenRepository,
+	profileRepo repository.ProfileRepository,
+	logger *zap.Logger,
+) TokenService {
+	return &tokenServiceImpl{
+		tokenRepo:   tokenRepo,
+		profileRepo: profileRepo,
+		logger:      logger,
+	}
+}
+
 const (
-	ExtendedTimeout = 10 * time.Second
-	TokensMaxCount  = 10 // 用户最多保留的token数量
+	tokenExtendedTimeout = 10 * time.Second
+	tokensMaxCount       = 10
 )
 
-// NewToken 创建新令牌
-func NewToken(db *gorm.DB, logger *zap.Logger, userId int64, UUID string, clientToken string) (*model.Profile, []*model.Profile, string, string, error) {
+func (s *tokenServiceImpl) Create(userID int64, UUID string, clientToken string) (*model.Profile, []*model.Profile, string, string, error) {
 	var (
 		selectedProfileID *model.Profile
 		availableProfiles []*model.Profile
 	)
+
 	// 设置超时上下文
 	_, cancel := context.WithTimeout(context.Background(), DefaultTimeout)
 	defer cancel()
 
 	// 验证用户存在
-	_, err := repository.FindProfileByUUID(UUID)
-	if err != nil {
-		return selectedProfileID, availableProfiles, "", "", fmt.Errorf("获取用户信息失败: %w", err)
+	if UUID != "" {
+		_, err := s.profileRepo.FindByUUID(UUID)
+		if err != nil {
+			return selectedProfileID, availableProfiles, "", "", fmt.Errorf("获取用户信息失败: %w", err)
+		}
 	}
 
 	// 生成令牌
@@ -46,13 +66,13 @@ func NewToken(db *gorm.DB, logger *zap.Logger, userId int64, UUID string, client
 	token := model.Token{
 		AccessToken: accessToken,
 		ClientToken: clientToken,
-		UserID:      userId,
+		UserID:      userID,
 		Usable:      true,
 		IssueDate:   time.Now(),
 	}
 
 	// 获取用户配置文件
-	profiles, err := repository.FindProfilesByUserID(userId)
+	profiles, err := s.profileRepo.FindByUserID(userID)
 	if err != nil {
 		return selectedProfileID, availableProfiles, "", "", fmt.Errorf("获取用户配置文件失败: %w", err)
 	}
@@ -64,65 +84,24 @@ func NewToken(db *gorm.DB, logger *zap.Logger, userId int64, UUID string, client
 	}
 	availableProfiles = profiles
 
-	// 插入令牌到tokens集合
-	_, insertCancel := context.WithTimeout(context.Background(), DefaultTimeout)
-	defer insertCancel()
-
-	err = repository.CreateToken(&token)
+	// 插入令牌
+	err = s.tokenRepo.Create(&token)
 	if err != nil {
 		return selectedProfileID, availableProfiles, "", "", fmt.Errorf("创建Token失败: %w", err)
 	}
+
 	// 清理多余的令牌
-	go CheckAndCleanupExcessTokens(db, logger, userId)
+	go s.checkAndCleanupExcessTokens(userID)
 
 	return selectedProfileID, availableProfiles, accessToken, clientToken, nil
 }
 
-// CheckAndCleanupExcessTokens 检查并清理用户多余的令牌，只保留最新的10个
-func CheckAndCleanupExcessTokens(db *gorm.DB, logger *zap.Logger, userId int64) {
-	if userId == 0 {
-		return
-	}
-	// 获取用户所有令牌，按发行日期降序排序
-	tokens, err := repository.GetTokensByUserId(userId)
-	if err != nil {
-		logger.Error("[ERROR] 获取用户Token失败: ", zap.Error(err), zap.String("userId", strconv.FormatInt(userId, 10)))
-		return
-	}
-
-	// 如果令牌数量不超过上限，无需清理
-	if len(tokens) <= TokensMaxCount {
-		return
-	}
-
-	// 获取需要删除的令牌ID列表
-	tokensToDelete := make([]string, 0, len(tokens)-TokensMaxCount)
-	for i := TokensMaxCount; i < len(tokens); i++ {
-		tokensToDelete = append(tokensToDelete, tokens[i].AccessToken)
-	}
-
-	// 执行批量删除，传入上下文和待删除的令牌列表（作为切片参数）
-	DeletedCount, err := repository.BatchDeleteTokens(tokensToDelete)
-	if err != nil {
-		logger.Error("[ERROR] 清理用户多余Token失败: ", zap.Error(err), zap.String("userId", strconv.FormatInt(userId, 10)))
-		return
-	}
-
-	if DeletedCount > 0 {
-		logger.Info("[INFO] 成功清理用户多余Token", zap.Any("userId:", userId), zap.Any("count:", DeletedCount))
-	}
-}
-
-// ValidToken 验证令牌有效性
-func ValidToken(db *gorm.DB, accessToken string, clientToken string) bool {
+func (s *tokenServiceImpl) Validate(accessToken, clientToken string) bool {
 	if accessToken == "" {
 		return false
 	}
 
-	// 使用投影只获取需要的字段
-	var token *model.Token
-	token, err := repository.FindTokenByID(accessToken)
-
+	token, err := s.tokenRepo.FindByAccessToken(accessToken)
 	if err != nil {
 		return false
 	}
@@ -131,47 +110,35 @@ func ValidToken(db *gorm.DB, accessToken string, clientToken string) bool {
 		return false
 	}
 
-	// 如果客户端令牌为空，只验证访问令牌
 	if clientToken == "" {
 		return true
 	}
 
-	// 否则验证客户端令牌是否匹配
 	return token.ClientToken == clientToken
 }
 
-func GetUUIDByAccessToken(db *gorm.DB, accessToken string) (string, error) {
-	return repository.GetUUIDByAccessToken(accessToken)
-}
-
-func GetUserIDByAccessToken(db *gorm.DB, accessToken string) (int64, error) {
-	return repository.GetUserIDByAccessToken(accessToken)
-}
-
-// RefreshToken 刷新令牌
-func RefreshToken(db *gorm.DB, logger *zap.Logger, accessToken, clientToken string, selectedProfileID string) (string, string, error) {
+func (s *tokenServiceImpl) Refresh(accessToken, clientToken, selectedProfileID string) (string, string, error) {
 	if accessToken == "" {
 		return "", "", errors.New("accessToken不能为空")
 	}
 
 	// 查找旧令牌
-	oldToken, err := repository.GetTokenByAccessToken(accessToken)
+	oldToken, err := s.tokenRepo.FindByAccessToken(accessToken)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return "", "", errors.New("accessToken无效")
 		}
-		logger.Error("[ERROR] 查询Token失败: ", zap.Error(err), zap.Any("accessToken:", accessToken))
+		s.logger.Error("查询Token失败", zap.Error(err), zap.String("accessToken", accessToken))
 		return "", "", fmt.Errorf("查询令牌失败: %w", err)
 	}
 
 	// 验证profile
 	if selectedProfileID != "" {
-		valid, validErr := ValidateProfileByUserID(db, oldToken.UserID, selectedProfileID)
+		valid, validErr := s.validateProfileByUserID(oldToken.UserID, selectedProfileID)
 		if validErr != nil {
-			logger.Error(
-				"验证Profile失败",
+			s.logger.Error("验证Profile失败",
 				zap.Error(err),
-				zap.Any("userId", oldToken.UserID),
+				zap.Int64("userId", oldToken.UserID),
 				zap.String("profileId", selectedProfileID),
 			)
 			return "", "", fmt.Errorf("验证角色失败: %w", err)
@@ -192,86 +159,119 @@ func RefreshToken(db *gorm.DB, logger *zap.Logger, accessToken, clientToken stri
 			return "", "", errors.New("原令牌已绑定角色，无法选择新角色")
 		}
 	} else {
-		selectedProfileID = oldToken.ProfileId // 如果未指定，则保持原角色
+		selectedProfileID = oldToken.ProfileId
 	}
 
 	// 生成新令牌
 	newAccessToken := uuid.New().String()
 	newToken := model.Token{
 		AccessToken: newAccessToken,
-		ClientToken: oldToken.ClientToken, // 新令牌的 clientToken 与原令牌相同
+		ClientToken: oldToken.ClientToken,
 		UserID:      oldToken.UserID,
 		Usable:      true,
-		ProfileId:   selectedProfileID, // 绑定到指定角色或保持原角色
+		ProfileId:   selectedProfileID,
 		IssueDate:   time.Now(),
 	}
 
-	// 使用双重写入模式替代事务，先插入新令牌，再删除旧令牌
-
-	err = repository.CreateToken(&newToken)
+	// 先插入新令牌，再删除旧令牌
+	err = s.tokenRepo.Create(&newToken)
 	if err != nil {
-		logger.Error(
-			"创建新Token失败",
-			zap.Error(err),
-			zap.String("accessToken", accessToken),
-		)
+		s.logger.Error("创建新Token失败", zap.Error(err), zap.String("accessToken", accessToken))
 		return "", "", fmt.Errorf("创建新Token失败: %w", err)
 	}
 
-	err = repository.DeleteTokenByAccessToken(accessToken)
+	err = s.tokenRepo.DeleteByAccessToken(accessToken)
 	if err != nil {
-		// 删除旧令牌失败，记录日志但不阻止操作，因为新令牌已成功创建
-		logger.Warn(
-			"删除旧Token失败，但新Token已创建",
+		s.logger.Warn("删除旧Token失败，但新Token已创建",
 			zap.Error(err),
 			zap.String("oldToken", oldToken.AccessToken),
 			zap.String("newToken", newAccessToken),
 		)
 	}
 
-	logger.Info(
-		"成功刷新Token",
-		zap.Any("userId", oldToken.UserID),
-		zap.String("accessToken", newAccessToken),
-	)
+	s.logger.Info("成功刷新Token", zap.Int64("userId", oldToken.UserID), zap.String("accessToken", newAccessToken))
 	return newAccessToken, oldToken.ClientToken, nil
 }
 
-// InvalidToken 使令牌失效
-func InvalidToken(db *gorm.DB, logger *zap.Logger, accessToken string) {
+func (s *tokenServiceImpl) Invalidate(accessToken string) {
 	if accessToken == "" {
 		return
 	}
 
-	err := repository.DeleteTokenByAccessToken(accessToken)
+	err := s.tokenRepo.DeleteByAccessToken(accessToken)
 	if err != nil {
-		logger.Error(
-			"删除Token失败",
-			zap.Error(err),
-			zap.String("accessToken", accessToken),
-		)
+		s.logger.Error("删除Token失败", zap.Error(err), zap.String("accessToken", accessToken))
 		return
 	}
-	logger.Info("[INFO] 成功删除", zap.Any("Token:", accessToken))
-
+	s.logger.Info("成功删除Token", zap.String("token", accessToken))
 }
 
-// InvalidUserTokens 使用户所有令牌失效
-func InvalidUserTokens(db *gorm.DB, logger *zap.Logger, userId int64) {
-	if userId == 0 {
+func (s *tokenServiceImpl) InvalidateUserTokens(userID int64) {
+	if userID == 0 {
 		return
 	}
 
-	err := repository.DeleteTokenByUserId(userId)
+	err := s.tokenRepo.DeleteByUserID(userID)
 	if err != nil {
-		logger.Error(
-			"[ERROR]删除用户Token失败",
-			zap.Error(err),
-			zap.Any("userId", userId),
-		)
+		s.logger.Error("删除用户Token失败", zap.Error(err), zap.Int64("userId", userID))
 		return
 	}
 
-	logger.Info("[INFO] 成功删除用户Token", zap.Any("userId:", userId))
-
+	s.logger.Info("成功删除用户Token", zap.Int64("userId", userID))
+}
+
+func (s *tokenServiceImpl) GetUUIDByAccessToken(accessToken string) (string, error) {
+	return s.tokenRepo.GetUUIDByAccessToken(accessToken)
+}
+
+func (s *tokenServiceImpl) GetUserIDByAccessToken(accessToken string) (int64, error) {
+	return s.tokenRepo.GetUserIDByAccessToken(accessToken)
+}
+
+// 私有辅助方法
+
+func (s *tokenServiceImpl) checkAndCleanupExcessTokens(userID int64) {
+	if userID == 0 {
+		return
+	}
+
+	tokens, err := s.tokenRepo.GetByUserID(userID)
+	if err != nil {
+		s.logger.Error("获取用户Token失败", zap.Error(err), zap.String("userId", strconv.FormatInt(userID, 10)))
+		return
+	}
+
+	if len(tokens) <= tokensMaxCount {
+		return
+	}
+
+	tokensToDelete := make([]string, 0, len(tokens)-tokensMaxCount)
+	for i := tokensMaxCount; i < len(tokens); i++ {
+		tokensToDelete = append(tokensToDelete, tokens[i].AccessToken)
+	}
+
+	deletedCount, err := s.tokenRepo.BatchDelete(tokensToDelete)
+	if err != nil {
+		s.logger.Error("清理用户多余Token失败", zap.Error(err), zap.String("userId", strconv.FormatInt(userID, 10)))
+		return
+	}
+
+	if deletedCount > 0 {
+		s.logger.Info("成功清理用户多余Token", zap.Int64("userId", userID), zap.Int64("count", deletedCount))
+	}
+}
+
+func (s *tokenServiceImpl) validateProfileByUserID(userID int64, UUID string) (bool, error) {
+	if userID == 0 || UUID == "" {
+		return false, errors.New("用户ID或配置文件ID不能为空")
+	}
+
+	profile, err := s.profileRepo.FindByUUID(UUID)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return false, errors.New("配置文件不存在")
+		}
+		return false, fmt.Errorf("验证配置文件失败: %w", err)
+	}
+	return profile.UserID == userID, nil
 }

internal/service/token_service_impl.go

@@ -1,277 +0,0 @@
-package service
-
-import (
-	"carrotskin/internal/model"
-	"carrotskin/internal/repository"
-	"context"
-	"errors"
-	"fmt"
-	"strconv"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5"
-	"go.uber.org/zap"
-)
-
-// tokenServiceImpl TokenService的实现
-type tokenServiceImpl struct {
-	tokenRepo   repository.TokenRepository
-	profileRepo repository.ProfileRepository
-	logger      *zap.Logger
-}
-
-// NewTokenService 创建TokenService实例
-func NewTokenService(
-	tokenRepo repository.TokenRepository,
-	profileRepo repository.ProfileRepository,
-	logger *zap.Logger,
-) TokenService {
-	return &tokenServiceImpl{
-		tokenRepo:   tokenRepo,
-		profileRepo: profileRepo,
-		logger:      logger,
-	}
-}
-
-const (
-	tokenExtendedTimeout = 10 * time.Second
-	tokensMaxCount       = 10
-)
-
-func (s *tokenServiceImpl) Create(userID int64, UUID string, clientToken string) (*model.Profile, []*model.Profile, string, string, error) {
-	var (
-		selectedProfileID *model.Profile
-		availableProfiles []*model.Profile
-	)
-
-	// 设置超时上下文
-	_, cancel := context.WithTimeout(context.Background(), DefaultTimeout)
-	defer cancel()
-
-	// 验证用户存在
-	if UUID != "" {
-		_, err := s.profileRepo.FindByUUID(UUID)
-		if err != nil {
-			return selectedProfileID, availableProfiles, "", "", fmt.Errorf("获取用户信息失败: %w", err)
-		}
-	}
-
-	// 生成令牌
-	if clientToken == "" {
-		clientToken = uuid.New().String()
-	}
-
-	accessToken := uuid.New().String()
-	token := model.Token{
-		AccessToken: accessToken,
-		ClientToken: clientToken,
-		UserID:      userID,
-		Usable:      true,
-		IssueDate:   time.Now(),
-	}
-
-	// 获取用户配置文件
-	profiles, err := s.profileRepo.FindByUserID(userID)
-	if err != nil {
-		return selectedProfileID, availableProfiles, "", "", fmt.Errorf("获取用户配置文件失败: %w", err)
-	}
-
-	// 如果用户只有一个配置文件，自动选择
-	if len(profiles) == 1 {
-		selectedProfileID = profiles[0]
-		token.ProfileId = selectedProfileID.UUID
-	}
-	availableProfiles = profiles
-
-	// 插入令牌
-	err = s.tokenRepo.Create(&token)
-	if err != nil {
-		return selectedProfileID, availableProfiles, "", "", fmt.Errorf("创建Token失败: %w", err)
-	}
-
-	// 清理多余的令牌
-	go s.checkAndCleanupExcessTokens(userID)
-
-	return selectedProfileID, availableProfiles, accessToken, clientToken, nil
-}
-
-func (s *tokenServiceImpl) Validate(accessToken, clientToken string) bool {
-	if accessToken == "" {
-		return false
-	}
-
-	token, err := s.tokenRepo.FindByAccessToken(accessToken)
-	if err != nil {
-		return false
-	}
-
-	if !token.Usable {
-		return false
-	}
-
-	if clientToken == "" {
-		return true
-	}
-
-	return token.ClientToken == clientToken
-}
-
-func (s *tokenServiceImpl) Refresh(accessToken, clientToken, selectedProfileID string) (string, string, error) {
-	if accessToken == "" {
-		return "", "", errors.New("accessToken不能为空")
-	}
-
-	// 查找旧令牌
-	oldToken, err := s.tokenRepo.FindByAccessToken(accessToken)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return "", "", errors.New("accessToken无效")
-		}
-		s.logger.Error("查询Token失败", zap.Error(err), zap.String("accessToken", accessToken))
-		return "", "", fmt.Errorf("查询令牌失败: %w", err)
-	}
-
-	// 验证profile
-	if selectedProfileID != "" {
-		valid, validErr := s.validateProfileByUserID(oldToken.UserID, selectedProfileID)
-		if validErr != nil {
-			s.logger.Error("验证Profile失败",
-				zap.Error(err),
-				zap.Int64("userId", oldToken.UserID),
-				zap.String("profileId", selectedProfileID),
-			)
-			return "", "", fmt.Errorf("验证角色失败: %w", err)
-		}
-		if !valid {
-			return "", "", errors.New("角色与用户不匹配")
-		}
-	}
-
-	// 检查 clientToken 是否有效
-	if clientToken != "" && clientToken != oldToken.ClientToken {
-		return "", "", errors.New("clientToken无效")
-	}
-
-	// 检查 selectedProfileID 的逻辑
-	if selectedProfileID != "" {
-		if oldToken.ProfileId != "" && oldToken.ProfileId != selectedProfileID {
-			return "", "", errors.New("原令牌已绑定角色，无法选择新角色")
-		}
-	} else {
-		selectedProfileID = oldToken.ProfileId
-	}
-
-	// 生成新令牌
-	newAccessToken := uuid.New().String()
-	newToken := model.Token{
-		AccessToken: newAccessToken,
-		ClientToken: oldToken.ClientToken,
-		UserID:      oldToken.UserID,
-		Usable:      true,
-		ProfileId:   selectedProfileID,
-		IssueDate:   time.Now(),
-	}
-
-	// 先插入新令牌，再删除旧令牌
-	err = s.tokenRepo.Create(&newToken)
-	if err != nil {
-		s.logger.Error("创建新Token失败", zap.Error(err), zap.String("accessToken", accessToken))
-		return "", "", fmt.Errorf("创建新Token失败: %w", err)
-	}
-
-	err = s.tokenRepo.DeleteByAccessToken(accessToken)
-	if err != nil {
-		s.logger.Warn("删除旧Token失败，但新Token已创建",
-			zap.Error(err),
-			zap.String("oldToken", oldToken.AccessToken),
-			zap.String("newToken", newAccessToken),
-		)
-	}
-
-	s.logger.Info("成功刷新Token", zap.Int64("userId", oldToken.UserID), zap.String("accessToken", newAccessToken))
-	return newAccessToken, oldToken.ClientToken, nil
-}
-
-func (s *tokenServiceImpl) Invalidate(accessToken string) {
-	if accessToken == "" {
-		return
-	}
-
-	err := s.tokenRepo.DeleteByAccessToken(accessToken)
-	if err != nil {
-		s.logger.Error("删除Token失败", zap.Error(err), zap.String("accessToken", accessToken))
-		return
-	}
-	s.logger.Info("成功删除Token", zap.String("token", accessToken))
-}
-
-func (s *tokenServiceImpl) InvalidateUserTokens(userID int64) {
-	if userID == 0 {
-		return
-	}
-
-	err := s.tokenRepo.DeleteByUserID(userID)
-	if err != nil {
-		s.logger.Error("删除用户Token失败", zap.Error(err), zap.Int64("userId", userID))
-		return
-	}
-
-	s.logger.Info("成功删除用户Token", zap.Int64("userId", userID))
-}
-
-func (s *tokenServiceImpl) GetUUIDByAccessToken(accessToken string) (string, error) {
-	return s.tokenRepo.GetUUIDByAccessToken(accessToken)
-}
-
-func (s *tokenServiceImpl) GetUserIDByAccessToken(accessToken string) (int64, error) {
-	return s.tokenRepo.GetUserIDByAccessToken(accessToken)
-}
-
-// 私有辅助方法
-
-func (s *tokenServiceImpl) checkAndCleanupExcessTokens(userID int64) {
-	if userID == 0 {
-		return
-	}
-
-	tokens, err := s.tokenRepo.GetByUserID(userID)
-	if err != nil {
-		s.logger.Error("获取用户Token失败", zap.Error(err), zap.String("userId", strconv.FormatInt(userID, 10)))
-		return
-	}
-
-	if len(tokens) <= tokensMaxCount {
-		return
-	}
-
-	tokensToDelete := make([]string, 0, len(tokens)-tokensMaxCount)
-	for i := tokensMaxCount; i < len(tokens); i++ {
-		tokensToDelete = append(tokensToDelete, tokens[i].AccessToken)
-	}
-
-	deletedCount, err := s.tokenRepo.BatchDelete(tokensToDelete)
-	if err != nil {
-		s.logger.Error("清理用户多余Token失败", zap.Error(err), zap.String("userId", strconv.FormatInt(userID, 10)))
-		return
-	}
-
-	if deletedCount > 0 {
-		s.logger.Info("成功清理用户多余Token", zap.Int64("userId", userID), zap.Int64("count", deletedCount))
-	}
-}
-
-func (s *tokenServiceImpl) validateProfileByUserID(userID int64, UUID string) (bool, error) {
-	if userID == 0 || UUID == "" {
-		return false, errors.New("用户ID或配置文件ID不能为空")
-	}
-
-	profile, err := s.profileRepo.FindByUUID(UUID)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return false, errors.New("配置文件不存在")
-		}
-		return false, fmt.Errorf("验证配置文件失败: %w", err)
-	}
-	return profile.UserID == userID, nil
-}

internal/service/token_service_test.go

@@ -1,18 +1,23 @@
 package service
 
 import (
+	"carrotskin/internal/model"
+	"fmt"
 	"testing"
 	"time"
+
+	"go.uber.org/zap"
 )
 
 // TestTokenService_Constants 测试Token服务相关常量
 func TestTokenService_Constants(t *testing.T) {
-	if ExtendedTimeout != 10*time.Second {
-		t.Errorf("ExtendedTimeout = %v, want 10 seconds", ExtendedTimeout)
+	// 测试私有常量通过行为验证
+	if tokenExtendedTimeout != 10*time.Second {
+		t.Errorf("tokenExtendedTimeout = %v, want 10 seconds", tokenExtendedTimeout)
 	}
 
-	if TokensMaxCount != 10 {
-		t.Errorf("TokensMaxCount = %d, want 10", TokensMaxCount)
+	if tokensMaxCount != 10 {
+		t.Errorf("tokensMaxCount = %d, want 10", tokensMaxCount)
 	}
 }
 
@@ -22,8 +27,8 @@ func TestTokenService_Timeout(t *testing.T) {
 		t.Errorf("DefaultTimeout = %v, want 5 seconds", DefaultTimeout)
 	}
 
-	if ExtendedTimeout <= DefaultTimeout {
-		t.Errorf("ExtendedTimeout (%v) should be greater than DefaultTimeout (%v)", ExtendedTimeout, DefaultTimeout)
+	if tokenExtendedTimeout <= DefaultTimeout {
+		t.Errorf("tokenExtendedTimeout (%v) should be greater than DefaultTimeout (%v)", tokenExtendedTimeout, DefaultTimeout)
 	}
 }
 
@@ -202,3 +207,314 @@ func TestTokenService_UserIDValidation(t *testing.T) {
 		})
 	}
 }
+
+// ============================================================================
+// 使用 Mock 的集成测试
+// ============================================================================
+
+// TestTokenServiceImpl_Create 测试创建Token
+func TestTokenServiceImpl_Create(t *testing.T) {
+	tokenRepo := NewMockTokenRepository()
+	profileRepo := NewMockProfileRepository()
+	logger := zap.NewNop()
+
+	// 预置Profile
+	testProfile := &model.Profile{
+		UUID:     "test-profile-uuid",
+		UserID:   1,
+		Name:     "TestProfile",
+		IsActive: true,
+	}
+	profileRepo.Create(testProfile)
+
+	tokenService := NewTokenService(tokenRepo, profileRepo, logger)
+
+	tests := []struct {
+		name        string
+		userID      int64
+		uuid        string
+		clientToken string
+		wantErr     bool
+	}{
+		{
+			name:        "正常创建Token（指定UUID）",
+			userID:      1,
+			uuid:        "test-profile-uuid",
+			clientToken: "client-token-1",
+			wantErr:     false,
+		},
+		{
+			name:        "正常创建Token（空clientToken）",
+			userID:      1,
+			uuid:        "test-profile-uuid",
+			clientToken: "",
+			wantErr:     false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, _, accessToken, clientToken, err := tokenService.Create(tt.userID, tt.uuid, tt.clientToken)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Error("期望返回错误，但实际没有错误")
+				}
+			} else {
+				if err != nil {
+					t.Errorf("不期望返回错误: %v", err)
+					return
+				}
+				if accessToken == "" {
+					t.Error("accessToken不应为空")
+				}
+				if clientToken == "" {
+					t.Error("clientToken不应为空")
+				}
+			}
+		})
+	}
+}
+
+// TestTokenServiceImpl_Validate 测试验证Token
+func TestTokenServiceImpl_Validate(t *testing.T) {
+	tokenRepo := NewMockTokenRepository()
+	profileRepo := NewMockProfileRepository()
+	logger := zap.NewNop()
+
+	// 预置Token
+	testToken := &model.Token{
+		AccessToken: "valid-access-token",
+		ClientToken: "valid-client-token",
+		UserID:      1,
+		ProfileId:   "test-profile-uuid",
+		Usable:      true,
+	}
+	tokenRepo.Create(testToken)
+
+	tokenService := NewTokenService(tokenRepo, profileRepo, logger)
+
+	tests := []struct {
+		name        string
+		accessToken string
+		clientToken string
+		wantValid   bool
+	}{
+		{
+			name:        "有效Token（完全匹配）",
+			accessToken: "valid-access-token",
+			clientToken: "valid-client-token",
+			wantValid:   true,
+		},
+		{
+			name:        "有效Token（只检查accessToken）",
+			accessToken: "valid-access-token",
+			clientToken: "",
+			wantValid:   true,
+		},
+		{
+			name:        "无效Token（accessToken不存在）",
+			accessToken: "invalid-access-token",
+			clientToken: "",
+			wantValid:   false,
+		},
+		{
+			name:        "无效Token（clientToken不匹配）",
+			accessToken: "valid-access-token",
+			clientToken: "wrong-client-token",
+			wantValid:   false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			isValid := tokenService.Validate(tt.accessToken, tt.clientToken)
+
+			if isValid != tt.wantValid {
+				t.Errorf("Token验证结果不匹配: got %v, want %v", isValid, tt.wantValid)
+			}
+		})
+	}
+}
+
+// TestTokenServiceImpl_Invalidate 测试注销Token
+func TestTokenServiceImpl_Invalidate(t *testing.T) {
+	tokenRepo := NewMockTokenRepository()
+	profileRepo := NewMockProfileRepository()
+	logger := zap.NewNop()
+
+	// 预置Token
+	testToken := &model.Token{
+		AccessToken: "token-to-invalidate",
+		ClientToken: "client-token",
+		UserID:      1,
+		ProfileId:   "test-profile-uuid",
+		Usable:      true,
+	}
+	tokenRepo.Create(testToken)
+
+	tokenService := NewTokenService(tokenRepo, profileRepo, logger)
+
+	// 验证Token存在
+	isValid := tokenService.Validate("token-to-invalidate", "")
+	if !isValid {
+		t.Error("Token应该有效")
+	}
+
+	// 注销Token
+	tokenService.Invalidate("token-to-invalidate")
+
+	// 验证Token已失效（从repo中删除）
+	_, err := tokenRepo.FindByAccessToken("token-to-invalidate")
+	if err == nil {
+		t.Error("Token应该已被删除")
+	}
+}
+
+// TestTokenServiceImpl_InvalidateUserTokens 测试注销用户所有Token
+func TestTokenServiceImpl_InvalidateUserTokens(t *testing.T) {
+	tokenRepo := NewMockTokenRepository()
+	profileRepo := NewMockProfileRepository()
+	logger := zap.NewNop()
+
+	// 预置多个Token
+	for i := 1; i <= 3; i++ {
+		tokenRepo.Create(&model.Token{
+			AccessToken: fmt.Sprintf("user1-token-%d", i),
+			ClientToken: "client-token",
+			UserID:      1,
+			ProfileId:   "test-profile-uuid",
+			Usable:      true,
+		})
+	}
+	tokenRepo.Create(&model.Token{
+		AccessToken: "user2-token-1",
+		ClientToken: "client-token",
+		UserID:      2,
+		ProfileId:   "test-profile-uuid-2",
+		Usable:      true,
+	})
+
+	tokenService := NewTokenService(tokenRepo, profileRepo, logger)
+
+	// 注销用户1的所有Token
+	tokenService.InvalidateUserTokens(1)
+
+	// 验证用户1的Token已失效
+	tokens, _ := tokenRepo.GetByUserID(1)
+	if len(tokens) > 0 {
+		t.Errorf("用户1的Token应该全部被删除，但还剩 %d 个", len(tokens))
+	}
+
+	// 验证用户2的Token仍然存在
+	tokens2, _ := tokenRepo.GetByUserID(2)
+	if len(tokens2) != 1 {
+		t.Errorf("用户2的Token应该仍然存在，期望1个，实际 %d 个", len(tokens2))
+	}
+}
+
+// TestTokenServiceImpl_Refresh 覆盖 Refresh 的主要分支
+func TestTokenServiceImpl_Refresh(t *testing.T) {
+	tokenRepo := NewMockTokenRepository()
+	profileRepo := NewMockProfileRepository()
+	logger := zap.NewNop()
+
+	// 预置 Profile 与 Token
+	profile := &model.Profile{
+		UUID:   "profile-uuid",
+		UserID: 1,
+	}
+	profileRepo.Create(profile)
+
+	oldToken := &model.Token{
+		AccessToken: "old-token",
+		ClientToken: "client-token",
+		UserID:      1,
+		ProfileId:   "",
+		Usable:      true,
+	}
+	tokenRepo.Create(oldToken)
+
+	tokenService := NewTokenService(tokenRepo, profileRepo, logger)
+
+	// 正常刷新，不指定 profile
+	newAccess, client, err := tokenService.Refresh("old-token", "client-token", "")
+	if err != nil {
+		t.Fatalf("Refresh 正常情况失败: %v", err)
+	}
+	if newAccess == "" || client != "client-token" {
+		t.Fatalf("Refresh 返回值异常: access=%s, client=%s", newAccess, client)
+	}
+
+	// accessToken 为空
+	if _, _, err := tokenService.Refresh("", "client-token", ""); err == nil {
+		t.Fatalf("Refresh 在 accessToken 为空时应返回错误")
+	}
+}
+
+// TestTokenServiceImpl_GetByAccessToken 封装 GetUUIDByAccessToken / GetUserIDByAccessToken
+func TestTokenServiceImpl_GetByAccessToken(t *testing.T) {
+	tokenRepo := NewMockTokenRepository()
+	profileRepo := NewMockProfileRepository()
+	logger := zap.NewNop()
+
+	token := &model.Token{
+		AccessToken: "token-1",
+		UserID:      42,
+		ProfileId:   "profile-42",
+		Usable:      true,
+	}
+	tokenRepo.Create(token)
+
+	tokenService := NewTokenService(tokenRepo, profileRepo, logger)
+
+	uuid, err := tokenService.GetUUIDByAccessToken("token-1")
+	if err != nil || uuid != "profile-42" {
+		t.Fatalf("GetUUIDByAccessToken 返回错误: uuid=%s, err=%v", uuid, err)
+	}
+
+	uid, err := tokenService.GetUserIDByAccessToken("token-1")
+	if err != nil || uid != 42 {
+		t.Fatalf("GetUserIDByAccessToken 返回错误: uid=%d, err=%v", uid, err)
+	}
+}
+
+// TestTokenServiceImpl_validateProfileByUserID 直接测试内部校验逻辑
+func TestTokenServiceImpl_validateProfileByUserID(t *testing.T) {
+	tokenRepo := NewMockTokenRepository()
+	profileRepo := NewMockProfileRepository()
+	logger := zap.NewNop()
+
+	svc := &tokenServiceImpl{
+		tokenRepo:   tokenRepo,
+		profileRepo: profileRepo,
+		logger:      logger,
+	}
+
+	// 预置 Profile
+	profile := &model.Profile{
+		UUID:   "p-1",
+		UserID: 1,
+	}
+	profileRepo.Create(profile)
+
+	// 参数非法
+	if ok, err := svc.validateProfileByUserID(0, ""); err == nil || ok {
+		t.Fatalf("validateProfileByUserID 在参数非法时应返回错误")
+	}
+
+	// Profile 不存在
+	if ok, err := svc.validateProfileByUserID(1, "not-exists"); err == nil || ok {
+		t.Fatalf("validateProfileByUserID 在 Profile 不存在时应返回错误")
+	}
+
+	// 用户与 Profile 匹配
+	if ok, err := svc.validateProfileByUserID(1, "p-1"); err != nil || !ok {
+		t.Fatalf("validateProfileByUserID 匹配时应返回 true, err=%v", err)
+	}
+
+	// 用户与 Profile 不匹配
+	if ok, err := svc.validateProfileByUserID(2, "p-1"); err != nil || ok {
+		t.Fatalf("validateProfileByUserID 不匹配时应返回 false, err=%v", err)
+	}
+}

internal/service/upload_service.go

@@ -74,27 +74,38 @@ func ValidateFileName(fileName string, fileType FileType) error {
 	return nil
 }
 
-// GenerateAvatarUploadURL 生成头像上传URL
+// uploadStorageClient 为上传服务定义的最小依赖接口，便于单元测试注入 mock
+type uploadStorageClient interface {
+	GetBucket(name string) (string, error)
+	GeneratePresignedPostURL(ctx context.Context, bucketName, objectName string, minSize, maxSize int64, expires time.Duration) (*storage.PresignedPostPolicyResult, error)
+}
+
+// GenerateAvatarUploadURL 生成头像上传URL（对外导出）
 func GenerateAvatarUploadURL(ctx context.Context, storageClient *storage.StorageClient, userID int64, fileName string) (*storage.PresignedPostPolicyResult, error) {
+	return generateAvatarUploadURLWithClient(ctx, storageClient, userID, fileName)
+}
+
+// generateAvatarUploadURLWithClient 使用接口类型的内部实现，方便测试
+func generateAvatarUploadURLWithClient(ctx context.Context, storageClient uploadStorageClient, userID int64, fileName string) (*storage.PresignedPostPolicyResult, error) {
 	// 1. 验证文件名
 	if err := ValidateFileName(fileName, FileTypeAvatar); err != nil {
 		return nil, err
 	}
-	
+
 	// 2. 获取上传配置
 	uploadConfig := GetUploadConfig(FileTypeAvatar)
-	
+
 	// 3. 获取存储桶名称
 	bucketName, err := storageClient.GetBucket("avatars")
 	if err != nil {
 		return nil, fmt.Errorf("获取存储桶失败: %w", err)
 	}
-	
+
 	// 4. 生成对象名称（路径）
 	// 格式: user_{userId}/timestamp_{originalFileName}
 	timestamp := time.Now().Format("20060102150405")
 	objectName := fmt.Sprintf("user_%d/%s_%s", userID, timestamp, fileName)
-	
+
 	// 5. 生成预签名POST URL (使用存储客户端内置的 PublicURL)
 	result, err := storageClient.GeneratePresignedPostURL(
 		ctx,
@@ -107,37 +118,42 @@ func GenerateAvatarUploadURL(ctx context.Context, storageClient *storage.Storage
 	if err != nil {
 		return nil, fmt.Errorf("生成上传URL失败: %w", err)
 	}
-	
+
 	return result, nil
 }
 
-// GenerateTextureUploadURL 生成材质上传URL
+// GenerateTextureUploadURL 生成材质上传URL（对外导出）
 func GenerateTextureUploadURL(ctx context.Context, storageClient *storage.StorageClient, userID int64, fileName, textureType string) (*storage.PresignedPostPolicyResult, error) {
+	return generateTextureUploadURLWithClient(ctx, storageClient, userID, fileName, textureType)
+}
+
+// generateTextureUploadURLWithClient 使用接口类型的内部实现，方便测试
+func generateTextureUploadURLWithClient(ctx context.Context, storageClient uploadStorageClient, userID int64, fileName, textureType string) (*storage.PresignedPostPolicyResult, error) {
 	// 1. 验证文件名
 	if err := ValidateFileName(fileName, FileTypeTexture); err != nil {
 		return nil, err
 	}
-	
+
 	// 2. 验证材质类型
 	if textureType != "SKIN" && textureType != "CAPE" {
 		return nil, fmt.Errorf("无效的材质类型: %s", textureType)
 	}
-	
+
 	// 3. 获取上传配置
 	uploadConfig := GetUploadConfig(FileTypeTexture)
-	
+
 	// 4. 获取存储桶名称
 	bucketName, err := storageClient.GetBucket("textures")
 	if err != nil {
 		return nil, fmt.Errorf("获取存储桶失败: %w", err)
 	}
-	
+
 	// 5. 生成对象名称（路径）
 	// 格式: user_{userId}/{textureType}/timestamp_{originalFileName}
 	timestamp := time.Now().Format("20060102150405")
 	textureTypeFolder := strings.ToLower(textureType)
 	objectName := fmt.Sprintf("user_%d/%s/%s_%s", userID, textureTypeFolder, timestamp, fileName)
-	
+
 	// 6. 生成预签名POST URL (使用存储客户端内置的 PublicURL)
 	result, err := storageClient.GeneratePresignedPostURL(
 		ctx,
@@ -150,6 +166,6 @@ func GenerateTextureUploadURL(ctx context.Context, storageClient *storage.Storag
 	if err != nil {
 		return nil, fmt.Errorf("生成上传URL失败: %w", err)
 	}
-	
+
 	return result, nil
 }

internal/service/upload_service_test.go

@@ -1,9 +1,13 @@
 package service
 
 import (
+	"context"
+	"errors"
 	"strings"
 	"testing"
 	"time"
+
+	"carrotskin/pkg/storage"
 )
 
 // TestUploadService_FileTypes 测试文件类型常量
@@ -135,43 +139,43 @@ func TestGetUploadConfig_TextureConfig(t *testing.T) {
 // TestValidateFileName 测试文件名验证
 func TestValidateFileName(t *testing.T) {
 	tests := []struct {
-		name      string
-		fileName  string
-		fileType  FileType
-		wantErr   bool
+		name        string
+		fileName    string
+		fileType    FileType
+		wantErr     bool
 		errContains string
 	}{
 		{
-			name:      "有效的头像文件名",
-			fileName:  "avatar.png",
-			fileType:  FileTypeAvatar,
-			wantErr:   false,
+			name:     "有效的头像文件名",
+			fileName: "avatar.png",
+			fileType: FileTypeAvatar,
+			wantErr:  false,
 		},
 		{
-			name:      "有效的材质文件名",
-			fileName:  "texture.png",
-			fileType:  FileTypeTexture,
-			wantErr:   false,
+			name:     "有效的材质文件名",
+			fileName: "texture.png",
+			fileType: FileTypeTexture,
+			wantErr:  false,
 		},
 		{
-			name:      "文件名为空",
-			fileName:  "",
-			fileType:  FileTypeAvatar,
-			wantErr:   true,
+			name:        "文件名为空",
+			fileName:    "",
+			fileType:    FileTypeAvatar,
+			wantErr:     true,
 			errContains: "文件名不能为空",
 		},
 		{
-			name:      "不支持的文件扩展名",
-			fileName:  "file.txt",
-			fileType:  FileTypeAvatar,
-			wantErr:   true,
+			name:        "不支持的文件扩展名",
+			fileName:    "file.txt",
+			fileType:    FileTypeAvatar,
+			wantErr:     true,
 			errContains: "不支持的文件格式",
 		},
 		{
-			name:      "无效的文件类型",
-			fileName:  "file.png",
-			fileType:  FileType("invalid"),
-			wantErr:   true,
+			name:        "无效的文件类型",
+			fileName:    "file.png",
+			fileType:    FileType("invalid"),
+			wantErr:     true,
 			errContains: "不支持的文件类型",
 		},
 	}
@@ -277,3 +281,130 @@ func TestUploadConfig_Structure(t *testing.T) {
 	}
 }
 
+// mockStorageClient 用于单元测试的简单存储客户端假实现
+// 注意：这里只声明与 upload_service 使用到的方法，避免依赖真实 MinIO 客户端
+type mockStorageClient struct {
+	getBucketFn                func(name string) (string, error)
+	generatePresignedPostURLFn func(ctx context.Context, bucketName, objectName string, minSize, maxSize int64, expires time.Duration) (*storage.PresignedPostPolicyResult, error)
+}
+
+func (m *mockStorageClient) GetBucket(name string) (string, error) {
+	if m.getBucketFn != nil {
+		return m.getBucketFn(name)
+	}
+	return "", errors.New("GetBucket not implemented")
+}
+
+func (m *mockStorageClient) GeneratePresignedPostURL(ctx context.Context, bucketName, objectName string, minSize, maxSize int64, expires time.Duration) (*storage.PresignedPostPolicyResult, error) {
+	if m.generatePresignedPostURLFn != nil {
+		return m.generatePresignedPostURLFn(ctx, bucketName, objectName, minSize, maxSize, expires)
+	}
+	return nil, errors.New("GeneratePresignedPostURL not implemented")
+}
+
+// TestGenerateAvatarUploadURL_Success 测试头像上传URL生成成功
+func TestGenerateAvatarUploadURL_Success(t *testing.T) {
+	ctx := context.Background()
+
+	mockClient := &mockStorageClient{
+		getBucketFn: func(name string) (string, error) {
+			if name != "avatars" {
+				t.Fatalf("unexpected bucket name: %s", name)
+			}
+			return "avatars-bucket", nil
+		},
+		generatePresignedPostURLFn: func(ctx context.Context, bucketName, objectName string, minSize, maxSize int64, expires time.Duration) (*storage.PresignedPostPolicyResult, error) {
+			if bucketName != "avatars-bucket" {
+				t.Fatalf("unexpected bucketName: %s", bucketName)
+			}
+			if !strings.Contains(objectName, "user_") {
+				t.Fatalf("objectName should contain user_ prefix, got: %s", objectName)
+			}
+			if !strings.Contains(objectName, "avatar.png") {
+				t.Fatalf("objectName should contain original file name, got: %s", objectName)
+			}
+			// 检查大小与过期时间传递
+			if minSize != 1024 {
+				t.Fatalf("minSize = %d, want 1024", minSize)
+			}
+			if maxSize != 5*1024*1024 {
+				t.Fatalf("maxSize = %d, want 5MB", maxSize)
+			}
+			if expires != 15*time.Minute {
+				t.Fatalf("expires = %v, want 15m", expires)
+			}
+			return &storage.PresignedPostPolicyResult{
+				PostURL:  "http://example.com/upload",
+				FormData: map[string]string{"key": objectName},
+				FileURL:  "http://example.com/file/" + objectName,
+			}, nil
+		},
+	}
+
+	// 直接将 mock 实例转换为真实类型使用（依赖其方法集与被测代码一致）
+	storageClient := (*storage.StorageClient)(nil)
+	_ = storageClient // 避免未使用告警，实际调用仍通过 mockClient 完成
+
+	// 直接通过内部使用接口的实现进行测试，避免依赖真实 StorageClient
+	result, err := generateAvatarUploadURLWithClient(ctx, mockClient, 123, "avatar.png")
+
+	if err != nil {
+		t.Fatalf("GenerateAvatarUploadURL() error = %v, want nil", err)
+	}
+	if result == nil {
+		t.Fatalf("GenerateAvatarUploadURL() result is nil")
+	}
+	if result.PostURL == "" || result.FileURL == "" {
+		t.Fatalf("GenerateAvatarUploadURL() result has empty URLs: %+v", result)
+	}
+}
+
+// TestGenerateTextureUploadURL_Success 测试材质上传URL生成成功（SKIN/CAPE）
+func TestGenerateTextureUploadURL_Success(t *testing.T) {
+	ctx := context.Background()
+
+	tests := []struct {
+		name        string
+		textureType string
+	}{
+		{"SKIN 材质", "SKIN"},
+		{"CAPE 材质", "CAPE"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockClient := &mockStorageClient{
+				getBucketFn: func(name string) (string, error) {
+					if name != "textures" {
+						t.Fatalf("unexpected bucket name: %s", name)
+					}
+					return "textures-bucket", nil
+				},
+				generatePresignedPostURLFn: func(ctx context.Context, bucketName, objectName string, minSize, maxSize int64, expires time.Duration) (*storage.PresignedPostPolicyResult, error) {
+					if bucketName != "textures-bucket" {
+						t.Fatalf("unexpected bucketName: %s", bucketName)
+					}
+					if !strings.Contains(objectName, "texture.png") {
+						t.Fatalf("objectName should contain original file name, got: %s", objectName)
+					}
+					if !strings.Contains(objectName, "/"+strings.ToLower(tt.textureType)+"/") {
+						t.Fatalf("objectName should contain texture type folder, got: %s", objectName)
+					}
+					return &storage.PresignedPostPolicyResult{
+						PostURL:  "http://example.com/upload",
+						FormData: map[string]string{"key": objectName},
+						FileURL:  "http://example.com/file/" + objectName,
+					}, nil
+				},
+			}
+
+			result, err := generateTextureUploadURLWithClient(ctx, mockClient, 123, "texture.png", tt.textureType)
+			if err != nil {
+				t.Fatalf("generateTextureUploadURLWithClient() error = %v, want nil", err)
+			}
+			if result == nil || result.PostURL == "" || result.FileURL == "" {
+				t.Fatalf("generateTextureUploadURLWithClient() result invalid: %+v", result)
+			}
+		})
+	}
+}

internal/service/user_service.go

@@ -12,12 +12,39 @@ import (
 	"net/url"
 	"strings"
 	"time"
+
+	"go.uber.org/zap"
 )
 
-// RegisterUser 用户注册
-func RegisterUser(jwtService *auth.JWTService, username, password, email, avatar string) (*model.User, string, error) {
+// userServiceImpl UserService的实现
+type userServiceImpl struct {
+	userRepo   repository.UserRepository
+	configRepo repository.SystemConfigRepository
+	jwtService *auth.JWTService
+	redis      *redis.Client
+	logger     *zap.Logger
+}
+
+// NewUserService 创建UserService实例
+func NewUserService(
+	userRepo repository.UserRepository,
+	configRepo repository.SystemConfigRepository,
+	jwtService *auth.JWTService,
+	redisClient *redis.Client,
+	logger *zap.Logger,
+) UserService {
+	return &userServiceImpl{
+		userRepo:   userRepo,
+		configRepo: configRepo,
+		jwtService: jwtService,
+		redis:      redisClient,
+		logger:     logger,
+	}
+}
+
+func (s *userServiceImpl) Register(username, password, email, avatar string) (*model.User, string, error) {
 	// 检查用户名是否已存在
-	existingUser, err := repository.FindUserByUsername(username)
+	existingUser, err := s.userRepo.FindByUsername(username)
 	if err != nil {
 		return nil, "", err
 	}
@@ -26,7 +53,7 @@ func RegisterUser(jwtService *auth.JWTService, username, password, email, avatar
 	}
 
 	// 检查邮箱是否已存在
-	existingEmail, err := repository.FindUserByEmail(email)
+	existingEmail, err := s.userRepo.FindByEmail(email)
 	if err != nil {
 		return nil, "", err
 	}
@@ -40,15 +67,14 @@ func RegisterUser(jwtService *auth.JWTService, username, password, email, avatar
 		return nil, "", errors.New("密码加密失败")
 	}
 
-	// 确定头像URL：优先使用用户提供的头像，否则使用默认头像
+	// 确定头像URL
 	avatarURL := avatar
 	if avatarURL != "" {
-		// 验证用户提供的头像 URL 是否来自允许的域名
-		if err := ValidateAvatarURL(avatarURL); err != nil {
+		if err := s.ValidateAvatarURL(avatarURL); err != nil {
 			return nil, "", err
 		}
 	} else {
-		avatarURL = getDefaultAvatar()
+		avatarURL = s.getDefaultAvatar()
 	}
 
 	// 创建用户
@@ -62,12 +88,12 @@ func RegisterUser(jwtService *auth.JWTService, username, password, email, avatar
 		Points:   0,
 	}
 
-	if err := repository.CreateUser(user); err != nil {
+	if err := s.userRepo.Create(user); err != nil {
 		return nil, "", err
 	}
 
 	// 生成JWT Token
-	token, err := jwtService.GenerateToken(user.ID, user.Username, user.Role)
+	token, err := s.jwtService.GenerateToken(user.ID, user.Username, user.Role)
 	if err != nil {
 		return nil, "", errors.New("生成Token失败")
 	}
@@ -75,92 +101,56 @@ func RegisterUser(jwtService *auth.JWTService, username, password, email, avatar
 	return user, token, nil
 }
 
-// LoginUser 用户登录（支持用户名或邮箱登录）
-func LoginUser(jwtService *auth.JWTService, usernameOrEmail, password, ipAddress, userAgent string) (*model.User, string, error) {
-	return LoginUserWithRateLimit(nil, jwtService, usernameOrEmail, password, ipAddress, userAgent)
-}
-
-// LoginUserWithRateLimit 用户登录（带频率限制）
-func LoginUserWithRateLimit(redisClient *redis.Client, jwtService *auth.JWTService, usernameOrEmail, password, ipAddress, userAgent string) (*model.User, string, error) {
+func (s *userServiceImpl) Login(usernameOrEmail, password, ipAddress, userAgent string) (*model.User, string, error) {
 	ctx := context.Background()
 
-	// 检查账号是否被锁定（基于用户名/邮箱和IP）
-	if redisClient != nil {
+	// 检查账号是否被锁定
+	if s.redis != nil {
 		identifier := usernameOrEmail + ":" + ipAddress
-		locked, ttl, err := CheckLoginLocked(ctx, redisClient, identifier)
+		locked, ttl, err := CheckLoginLocked(ctx, s.redis, identifier)
 		if err == nil && locked {
 			return nil, "", fmt.Errorf("登录尝试次数过多，请在 %d 分钟后重试", int(ttl.Minutes())+1)
 		}
 	}
 
-	// 查找用户：判断是用户名还是邮箱
+	// 查找用户
 	var user *model.User
 	var err error
 
 	if strings.Contains(usernameOrEmail, "@") {
-		user, err = repository.FindUserByEmail(usernameOrEmail)
+		user, err = s.userRepo.FindByEmail(usernameOrEmail)
 	} else {
-		user, err = repository.FindUserByUsername(usernameOrEmail)
+		user, err = s.userRepo.FindByUsername(usernameOrEmail)
 	}
 
 	if err != nil {
 		return nil, "", err
 	}
 	if user == nil {
-		// 记录失败尝试
-		if redisClient != nil {
-			identifier := usernameOrEmail + ":" + ipAddress
-			count, _ := RecordLoginFailure(ctx, redisClient, identifier)
-			// 检查是否触发锁定
-			if count >= MaxLoginAttempts {
-				logFailedLogin(0, ipAddress, userAgent, "用户不存在-账号已锁定")
-				return nil, "", fmt.Errorf("登录失败次数过多，账号已被锁定 %d 分钟", int(LoginLockDuration.Minutes()))
-			}
-			remaining := MaxLoginAttempts - count
-			if remaining > 0 {
-				logFailedLogin(0, ipAddress, userAgent, "用户不存在")
-				return nil, "", fmt.Errorf("用户名/邮箱或密码错误，还剩 %d 次尝试机会", remaining)
-			}
-		}
-		logFailedLogin(0, ipAddress, userAgent, "用户不存在")
+		s.recordLoginFailure(ctx, usernameOrEmail, ipAddress, userAgent, 0, "用户不存在")
 		return nil, "", errors.New("用户名/邮箱或密码错误")
 	}
 
 	// 检查用户状态
 	if user.Status != 1 {
-		logFailedLogin(user.ID, ipAddress, userAgent, "账号已被禁用")
+		s.recordLoginFailure(ctx, usernameOrEmail, ipAddress, userAgent, user.ID, "账号已被禁用")
 		return nil, "", errors.New("账号已被禁用")
 	}
 
 	// 验证密码
 	if !auth.CheckPassword(user.Password, password) {
-		// 记录失败尝试
-		if redisClient != nil {
-			identifier := usernameOrEmail + ":" + ipAddress
-			count, _ := RecordLoginFailure(ctx, redisClient, identifier)
-			// 检查是否触发锁定
-			if count >= MaxLoginAttempts {
-				logFailedLogin(user.ID, ipAddress, userAgent, "密码错误-账号已锁定")
-				return nil, "", fmt.Errorf("登录失败次数过多，账号已被锁定 %d 分钟", int(LoginLockDuration.Minutes()))
-			}
-			remaining := MaxLoginAttempts - count
-			if remaining > 0 {
-				logFailedLogin(user.ID, ipAddress, userAgent, "密码错误")
-				return nil, "", fmt.Errorf("用户名/邮箱或密码错误，还剩 %d 次尝试机会", remaining)
-			}
-		}
-		logFailedLogin(user.ID, ipAddress, userAgent, "密码错误")
+		s.recordLoginFailure(ctx, usernameOrEmail, ipAddress, userAgent, user.ID, "密码错误")
 		return nil, "", errors.New("用户名/邮箱或密码错误")
 	}
 
 	// 登录成功，清除失败计数
-	if redisClient != nil {
+	if s.redis != nil {
 		identifier := usernameOrEmail + ":" + ipAddress
-		_ = ClearLoginAttempts(ctx, redisClient, identifier)
+		_ = ClearLoginAttempts(ctx, s.redis, identifier)
 	}
 
 	// 生成JWT Token
-	token, err := jwtService.GenerateToken(user.ID, user.Username, user.Role)
+	token, err := s.jwtService.GenerateToken(user.ID, user.Username, user.Role)
 	if err != nil {
 		return nil, "", errors.New("生成Token失败")
 	}
@@ -168,37 +158,37 @@ func LoginUserWithRateLimit(redisClient *redis.Client, jwtService *auth.JWTServi
 	// 更新最后登录时间
 	now := time.Now()
 	user.LastLoginAt = &now
-	_ = repository.UpdateUserFields(user.ID, map[string]interface{}{
+	_ = s.userRepo.UpdateFields(user.ID, map[string]interface{}{
 		"last_login_at": now,
 	})
 
 	// 记录成功登录日志
-	logSuccessLogin(user.ID, ipAddress, userAgent)
+	s.logSuccessLogin(user.ID, ipAddress, userAgent)
 
 	return user, token, nil
 }
 
-// GetUserByID 根据ID获取用户
-func GetUserByID(id int64) (*model.User, error) {
-	return repository.FindUserByID(id)
+func (s *userServiceImpl) GetByID(id int64) (*model.User, error) {
+	return s.userRepo.FindByID(id)
 }
 
-// UpdateUserInfo 更新用户信息
-func UpdateUserInfo(user *model.User) error {
-	return repository.UpdateUser(user)
+func (s *userServiceImpl) GetByEmail(email string) (*model.User, error) {
+	return s.userRepo.FindByEmail(email)
 }
 
-// UpdateUserAvatar 更新用户头像
-func UpdateUserAvatar(userID int64, avatarURL string) error {
-	return repository.UpdateUserFields(userID, map[string]interface{}{
+func (s *userServiceImpl) UpdateInfo(user *model.User) error {
+	return s.userRepo.Update(user)
+}
+
+func (s *userServiceImpl) UpdateAvatar(userID int64, avatarURL string) error {
+	return s.userRepo.UpdateFields(userID, map[string]interface{}{
 		"avatar": avatarURL,
 	})
 }
 
-// ChangeUserPassword 修改密码
-func ChangeUserPassword(userID int64, oldPassword, newPassword string) error {
-	user, err := repository.FindUserByID(userID)
-	if err != nil {
+func (s *userServiceImpl) ChangePassword(userID int64, oldPassword, newPassword string) error {
+	user, err := s.userRepo.FindByID(userID)
+	if err != nil || user == nil {
 		return errors.New("用户不存在")
 	}
 
@@ -211,15 +201,14 @@ func ChangeUserPassword(userID int64, oldPassword, newPassword string) error {
 		return errors.New("密码加密失败")
 	}
 
-	return repository.UpdateUserFields(userID, map[string]interface{}{
+	return s.userRepo.UpdateFields(userID, map[string]interface{}{
 		"password": hashedPassword,
 	})
 }
 
-// ResetUserPassword 重置密码（通过邮箱）
-func ResetUserPassword(email, newPassword string) error {
-	user, err := repository.FindUserByEmail(email)
-	if err != nil {
+func (s *userServiceImpl) ResetPassword(email, newPassword string) error {
+	user, err := s.userRepo.FindByEmail(email)
+	if err != nil || user == nil {
 		return errors.New("用户不存在")
 	}
 
@@ -228,14 +217,13 @@ func ResetUserPassword(email, newPassword string) error {
 		return errors.New("密码加密失败")
 	}
 
-	return repository.UpdateUserFields(user.ID, map[string]interface{}{
+	return s.userRepo.UpdateFields(user.ID, map[string]interface{}{
 		"password": hashedPassword,
 	})
 }
 
-// ChangeUserEmail 更换邮箱
-func ChangeUserEmail(userID int64, newEmail string) error {
-	existingUser, err := repository.FindUserByEmail(newEmail)
+func (s *userServiceImpl) ChangeEmail(userID int64, newEmail string) error {
+	existingUser, err := s.userRepo.FindByEmail(newEmail)
 	if err != nil {
 		return err
 	}
@@ -243,47 +231,12 @@ func ChangeUserEmail(userID int64, newEmail string) error {
 		return errors.New("邮箱已被其他用户使用")
 	}
 
-	return repository.UpdateUserFields(userID, map[string]interface{}{
+	return s.userRepo.UpdateFields(userID, map[string]interface{}{
 		"email": newEmail,
 	})
 }
 
-// logSuccessLogin 记录成功登录
-func logSuccessLogin(userID int64, ipAddress, userAgent string) {
-	log := &model.UserLoginLog{
-		UserID:      userID,
-		IPAddress:   ipAddress,
-		UserAgent:   userAgent,
-		LoginMethod: "PASSWORD",
-		IsSuccess:   true,
-	}
-	_ = repository.CreateLoginLog(log)
-}
-
-// logFailedLogin 记录失败登录
-func logFailedLogin(userID int64, ipAddress, userAgent, reason string) {
-	log := &model.UserLoginLog{
-		UserID:        userID,
-		IPAddress:     ipAddress,
-		UserAgent:     userAgent,
-		LoginMethod:   "PASSWORD",
-		IsSuccess:     false,
-		FailureReason: reason,
-	}
-	_ = repository.CreateLoginLog(log)
-}
-
-// getDefaultAvatar 获取默认头像URL
-func getDefaultAvatar() string {
-	config, err := repository.GetSystemConfigByKey("default_avatar")
-	if err != nil || config == nil || config.Value == "" {
-		return ""
-	}
-	return config.Value
-}
-
-// ValidateAvatarURL 验证头像URL是否合法
-func ValidateAvatarURL(avatarURL string) error {
+func (s *userServiceImpl) ValidateAvatarURL(avatarURL string) error {
 	if avatarURL == "" {
 		return nil
 	}
@@ -293,13 +246,8 @@ func ValidateAvatarURL(avatarURL string) error {
 		return nil
 	}
 
-	return ValidateURLDomain(avatarURL)
-}
-
-// ValidateURLDomain 验证URL的域名是否在允许列表中
-func ValidateURLDomain(rawURL string) error {
 	// 解析URL
-	parsedURL, err := url.Parse(rawURL)
+	parsedURL, err := url.Parse(avatarURL)
 	if err != nil {
 		return errors.New("无效的URL格式")
 	}
@@ -309,7 +257,6 @@ func ValidateURLDomain(rawURL string) error {
 		return errors.New("URL必须使用http或https协议")
 	}
 
-	// 获取主机名（不包含端口）
 	host := parsedURL.Hostname()
 	if host == "" {
 		return errors.New("URL缺少主机名")
@@ -318,16 +265,50 @@ func ValidateURLDomain(rawURL string) error {
 	// 从配置获取允许的域名列表
 	cfg, err := config.GetConfig()
 	if err != nil {
-		// 如果配置获取失败，使用默认的安全域名列表
 		allowedDomains := []string{"localhost", "127.0.0.1"}
-		return checkDomainAllowed(host, allowedDomains)
+		return s.checkDomainAllowed(host, allowedDomains)
 	}
 
-	return checkDomainAllowed(host, cfg.Security.AllowedDomains)
+	return s.checkDomainAllowed(host, cfg.Security.AllowedDomains)
 }
 
-// checkDomainAllowed 检查域名是否在允许列表中
-func checkDomainAllowed(host string, allowedDomains []string) error {
+func (s *userServiceImpl) GetMaxProfilesPerUser() int {
+	config, err := s.configRepo.GetByKey("max_profiles_per_user")
+	if err != nil || config == nil {
+		return 5
+	}
+	var value int
+	fmt.Sscanf(config.Value, "%d", &value)
+	if value <= 0 {
+		return 5
+	}
+	return value
+}
+
+func (s *userServiceImpl) GetMaxTexturesPerUser() int {
+	config, err := s.configRepo.GetByKey("max_textures_per_user")
+	if err != nil || config == nil {
+		return 50
+	}
+	var value int
+	fmt.Sscanf(config.Value, "%d", &value)
+	if value <= 0 {
+		return 50
+	}
+	return value
+}
+
+// 私有辅助方法
+
+func (s *userServiceImpl) getDefaultAvatar() string {
+	config, err := s.configRepo.GetByKey("default_avatar")
+	if err != nil || config == nil || config.Value == "" {
+		return ""
+	}
+	return config.Value
+}
+
+func (s *userServiceImpl) checkDomainAllowed(host string, allowedDomains []string) error {
 	host = strings.ToLower(host)
 
 	for _, allowed := range allowedDomains {
@@ -336,14 +317,12 @@ func checkDomainAllowed(host string, allowedDomains []string) error {
 			continue
 		}
 
-		// 精确匹配
 		if host == allowed {
 			return nil
 		}
 
-		// 支持通配符子域名匹配 (如 *.example.com)
 		if strings.HasPrefix(allowed, "*.") {
-			suffix := allowed[1:] // 移除 "*"，保留 ".example.com"
+			suffix := allowed[1:]
 			if strings.HasSuffix(host, suffix) {
 				return nil
 			}
@@ -353,39 +332,37 @@ func checkDomainAllowed(host string, allowedDomains []string) error {
 	return errors.New("URL域名不在允许的列表中")
 }
 
-// GetUserByEmail 根据邮箱获取用户
-func GetUserByEmail(email string) (*model.User, error) {
-	user, err := repository.FindUserByEmail(email)
-	if err != nil {
-		return nil, errors.New("邮箱查找失败")
+func (s *userServiceImpl) recordLoginFailure(ctx context.Context, usernameOrEmail, ipAddress, userAgent string, userID int64, reason string) {
+	if s.redis != nil {
+		identifier := usernameOrEmail + ":" + ipAddress
+		count, _ := RecordLoginFailure(ctx, s.redis, identifier)
+		if count >= MaxLoginAttempts {
+			s.logFailedLogin(userID, ipAddress, userAgent, reason+"-账号已锁定")
+			return
+		}
 	}
-	return user, nil
+	s.logFailedLogin(userID, ipAddress, userAgent, reason)
 }
 
-// GetMaxProfilesPerUser 获取每用户最大档案数量配置
-func GetMaxProfilesPerUser() int {
-	config, err := repository.GetSystemConfigByKey("max_profiles_per_user")
-	if err != nil || config == nil {
-		return 5
+func (s *userServiceImpl) logSuccessLogin(userID int64, ipAddress, userAgent string) {
+	log := &model.UserLoginLog{
+		UserID:      userID,
+		IPAddress:   ipAddress,
+		UserAgent:   userAgent,
+		LoginMethod: "PASSWORD",
+		IsSuccess:   true,
 	}
-	var value int
-	fmt.Sscanf(config.Value, "%d", &value)
-	if value <= 0 {
-		return 5
-	}
-	return value
+	_ = s.userRepo.CreateLoginLog(log)
 }
 
-// GetMaxTexturesPerUser 获取每用户最大材质数量配置
-func GetMaxTexturesPerUser() int {
-	config, err := repository.GetSystemConfigByKey("max_textures_per_user")
-	if err != nil || config == nil {
-		return 50
+func (s *userServiceImpl) logFailedLogin(userID int64, ipAddress, userAgent, reason string) {
+	log := &model.UserLoginLog{
+		UserID:        userID,
+		IPAddress:     ipAddress,
+		UserAgent:     userAgent,
+		LoginMethod:   "PASSWORD",
+		IsSuccess:     false,
+		FailureReason: reason,
 	}
-	var value int
-	fmt.Sscanf(config.Value, "%d", &value)
-	if value <= 0 {
-		return 50
-	}
-	return value
+	_ = s.userRepo.CreateLoginLog(log)
 }

internal/service/user_service_impl.go

@@ -1,368 +0,0 @@
-package service
-
-import (
-	"carrotskin/internal/model"
-	"carrotskin/internal/repository"
-	"carrotskin/pkg/auth"
-	"carrotskin/pkg/config"
-	"carrotskin/pkg/redis"
-	"context"
-	"errors"
-	"fmt"
-	"net/url"
-	"strings"
-	"time"
-
-	"go.uber.org/zap"
-)
-
-// userServiceImpl UserService的实现
-type userServiceImpl struct {
-	userRepo   repository.UserRepository
-	configRepo repository.SystemConfigRepository
-	jwtService *auth.JWTService
-	redis      *redis.Client
-	logger     *zap.Logger
-}
-
-// NewUserService 创建UserService实例
-func NewUserService(
-	userRepo repository.UserRepository,
-	configRepo repository.SystemConfigRepository,
-	jwtService *auth.JWTService,
-	redisClient *redis.Client,
-	logger *zap.Logger,
-) UserService {
-	return &userServiceImpl{
-		userRepo:   userRepo,
-		configRepo: configRepo,
-		jwtService: jwtService,
-		redis:      redisClient,
-		logger:     logger,
-	}
-}
-
-func (s *userServiceImpl) Register(username, password, email, avatar string) (*model.User, string, error) {
-	// 检查用户名是否已存在
-	existingUser, err := s.userRepo.FindByUsername(username)
-	if err != nil {
-		return nil, "", err
-	}
-	if existingUser != nil {
-		return nil, "", errors.New("用户名已存在")
-	}
-
-	// 检查邮箱是否已存在
-	existingEmail, err := s.userRepo.FindByEmail(email)
-	if err != nil {
-		return nil, "", err
-	}
-	if existingEmail != nil {
-		return nil, "", errors.New("邮箱已被注册")
-	}
-
-	// 加密密码
-	hashedPassword, err := auth.HashPassword(password)
-	if err != nil {
-		return nil, "", errors.New("密码加密失败")
-	}
-
-	// 确定头像URL
-	avatarURL := avatar
-	if avatarURL != "" {
-		if err := s.ValidateAvatarURL(avatarURL); err != nil {
-			return nil, "", err
-		}
-	} else {
-		avatarURL = s.getDefaultAvatar()
-	}
-
-	// 创建用户
-	user := &model.User{
-		Username: username,
-		Password: hashedPassword,
-		Email:    email,
-		Avatar:   avatarURL,
-		Role:     "user",
-		Status:   1,
-		Points:   0,
-	}
-
-	if err := s.userRepo.Create(user); err != nil {
-		return nil, "", err
-	}
-
-	// 生成JWT Token
-	token, err := s.jwtService.GenerateToken(user.ID, user.Username, user.Role)
-	if err != nil {
-		return nil, "", errors.New("生成Token失败")
-	}
-
-	return user, token, nil
-}
-
-func (s *userServiceImpl) Login(usernameOrEmail, password, ipAddress, userAgent string) (*model.User, string, error) {
-	ctx := context.Background()
-
-	// 检查账号是否被锁定
-	if s.redis != nil {
-		identifier := usernameOrEmail + ":" + ipAddress
-		locked, ttl, err := CheckLoginLocked(ctx, s.redis, identifier)
-		if err == nil && locked {
-			return nil, "", fmt.Errorf("登录尝试次数过多，请在 %d 分钟后重试", int(ttl.Minutes())+1)
-		}
-	}
-
-	// 查找用户
-	var user *model.User
-	var err error
-
-	if strings.Contains(usernameOrEmail, "@") {
-		user, err = s.userRepo.FindByEmail(usernameOrEmail)
-	} else {
-		user, err = s.userRepo.FindByUsername(usernameOrEmail)
-	}
-
-	if err != nil {
-		return nil, "", err
-	}
-	if user == nil {
-		s.recordLoginFailure(ctx, usernameOrEmail, ipAddress, userAgent, 0, "用户不存在")
-		return nil, "", errors.New("用户名/邮箱或密码错误")
-	}
-
-	// 检查用户状态
-	if user.Status != 1 {
-		s.recordLoginFailure(ctx, usernameOrEmail, ipAddress, userAgent, user.ID, "账号已被禁用")
-		return nil, "", errors.New("账号已被禁用")
-	}
-
-	// 验证密码
-	if !auth.CheckPassword(user.Password, password) {
-		s.recordLoginFailure(ctx, usernameOrEmail, ipAddress, userAgent, user.ID, "密码错误")
-		return nil, "", errors.New("用户名/邮箱或密码错误")
-	}
-
-	// 登录成功，清除失败计数
-	if s.redis != nil {
-		identifier := usernameOrEmail + ":" + ipAddress
-		_ = ClearLoginAttempts(ctx, s.redis, identifier)
-	}
-
-	// 生成JWT Token
-	token, err := s.jwtService.GenerateToken(user.ID, user.Username, user.Role)
-	if err != nil {
-		return nil, "", errors.New("生成Token失败")
-	}
-
-	// 更新最后登录时间
-	now := time.Now()
-	user.LastLoginAt = &now
-	_ = s.userRepo.UpdateFields(user.ID, map[string]interface{}{
-		"last_login_at": now,
-	})
-
-	// 记录成功登录日志
-	s.logSuccessLogin(user.ID, ipAddress, userAgent)
-
-	return user, token, nil
-}
-
-func (s *userServiceImpl) GetByID(id int64) (*model.User, error) {
-	return s.userRepo.FindByID(id)
-}
-
-func (s *userServiceImpl) GetByEmail(email string) (*model.User, error) {
-	return s.userRepo.FindByEmail(email)
-}
-
-func (s *userServiceImpl) UpdateInfo(user *model.User) error {
-	return s.userRepo.Update(user)
-}
-
-func (s *userServiceImpl) UpdateAvatar(userID int64, avatarURL string) error {
-	return s.userRepo.UpdateFields(userID, map[string]interface{}{
-		"avatar": avatarURL,
-	})
-}
-
-func (s *userServiceImpl) ChangePassword(userID int64, oldPassword, newPassword string) error {
-	user, err := s.userRepo.FindByID(userID)
-	if err != nil || user == nil {
-		return errors.New("用户不存在")
-	}
-
-	if !auth.CheckPassword(user.Password, oldPassword) {
-		return errors.New("原密码错误")
-	}
-
-	hashedPassword, err := auth.HashPassword(newPassword)
-	if err != nil {
-		return errors.New("密码加密失败")
-	}
-
-	return s.userRepo.UpdateFields(userID, map[string]interface{}{
-		"password": hashedPassword,
-	})
-}
-
-func (s *userServiceImpl) ResetPassword(email, newPassword string) error {
-	user, err := s.userRepo.FindByEmail(email)
-	if err != nil || user == nil {
-		return errors.New("用户不存在")
-	}
-
-	hashedPassword, err := auth.HashPassword(newPassword)
-	if err != nil {
-		return errors.New("密码加密失败")
-	}
-
-	return s.userRepo.UpdateFields(user.ID, map[string]interface{}{
-		"password": hashedPassword,
-	})
-}
-
-func (s *userServiceImpl) ChangeEmail(userID int64, newEmail string) error {
-	existingUser, err := s.userRepo.FindByEmail(newEmail)
-	if err != nil {
-		return err
-	}
-	if existingUser != nil && existingUser.ID != userID {
-		return errors.New("邮箱已被其他用户使用")
-	}
-
-	return s.userRepo.UpdateFields(userID, map[string]interface{}{
-		"email": newEmail,
-	})
-}
-
-func (s *userServiceImpl) ValidateAvatarURL(avatarURL string) error {
-	if avatarURL == "" {
-		return nil
-	}
-
-	// 允许相对路径
-	if strings.HasPrefix(avatarURL, "/") {
-		return nil
-	}
-
-	// 解析URL
-	parsedURL, err := url.Parse(avatarURL)
-	if err != nil {
-		return errors.New("无效的URL格式")
-	}
-
-	// 必须是HTTP或HTTPS协议
-	if parsedURL.Scheme != "http" && parsedURL.Scheme != "https" {
-		return errors.New("URL必须使用http或https协议")
-	}
-
-	host := parsedURL.Hostname()
-	if host == "" {
-		return errors.New("URL缺少主机名")
-	}
-
-	// 从配置获取允许的域名列表
-	cfg, err := config.GetConfig()
-	if err != nil {
-		allowedDomains := []string{"localhost", "127.0.0.1"}
-		return s.checkDomainAllowed(host, allowedDomains)
-	}
-
-	return s.checkDomainAllowed(host, cfg.Security.AllowedDomains)
-}
-
-func (s *userServiceImpl) GetMaxProfilesPerUser() int {
-	config, err := s.configRepo.GetByKey("max_profiles_per_user")
-	if err != nil || config == nil {
-		return 5
-	}
-	var value int
-	fmt.Sscanf(config.Value, "%d", &value)
-	if value <= 0 {
-		return 5
-	}
-	return value
-}
-
-func (s *userServiceImpl) GetMaxTexturesPerUser() int {
-	config, err := s.configRepo.GetByKey("max_textures_per_user")
-	if err != nil || config == nil {
-		return 50
-	}
-	var value int
-	fmt.Sscanf(config.Value, "%d", &value)
-	if value <= 0 {
-		return 50
-	}
-	return value
-}
-
-// 私有辅助方法
-
-func (s *userServiceImpl) getDefaultAvatar() string {
-	config, err := s.configRepo.GetByKey("default_avatar")
-	if err != nil || config == nil || config.Value == "" {
-		return ""
-	}
-	return config.Value
-}
-
-func (s *userServiceImpl) checkDomainAllowed(host string, allowedDomains []string) error {
-	host = strings.ToLower(host)
-
-	for _, allowed := range allowedDomains {
-		allowed = strings.ToLower(strings.TrimSpace(allowed))
-		if allowed == "" {
-			continue
-		}
-
-		if host == allowed {
-			return nil
-		}
-
-		if strings.HasPrefix(allowed, "*.") {
-			suffix := allowed[1:]
-			if strings.HasSuffix(host, suffix) {
-				return nil
-			}
-		}
-	}
-
-	return errors.New("URL域名不在允许的列表中")
-}
-
-func (s *userServiceImpl) recordLoginFailure(ctx context.Context, usernameOrEmail, ipAddress, userAgent string, userID int64, reason string) {
-	if s.redis != nil {
-		identifier := usernameOrEmail + ":" + ipAddress
-		count, _ := RecordLoginFailure(ctx, s.redis, identifier)
-		if count >= MaxLoginAttempts {
-			s.logFailedLogin(userID, ipAddress, userAgent, reason+"-账号已锁定")
-			return
-		}
-	}
-	s.logFailedLogin(userID, ipAddress, userAgent, reason)
-}
-
-func (s *userServiceImpl) logSuccessLogin(userID int64, ipAddress, userAgent string) {
-	log := &model.UserLoginLog{
-		UserID:      userID,
-		IPAddress:   ipAddress,
-		UserAgent:   userAgent,
-		LoginMethod: "PASSWORD",
-		IsSuccess:   true,
-	}
-	_ = s.userRepo.CreateLoginLog(log)
-}
-
-func (s *userServiceImpl) logFailedLogin(userID int64, ipAddress, userAgent, reason string) {
-	log := &model.UserLoginLog{
-		UserID:        userID,
-		IPAddress:     ipAddress,
-		UserAgent:     userAgent,
-		LoginMethod:   "PASSWORD",
-		IsSuccess:     false,
-		FailureReason: reason,
-	}
-	_ = s.userRepo.CreateLoginLog(log)
-}

internal/service/user_service_test.go

@@ -1,199 +1,378 @@
 package service
 
 import (
-	"strings"
+	"carrotskin/internal/model"
+	"carrotskin/pkg/auth"
 	"testing"
+
+	"go.uber.org/zap"
 )
 
-// TestGetDefaultAvatar 测试获取默认头像的逻辑
-// 注意：这个测试需要mock repository，但由于repository是函数式的，
-// 我们只测试逻辑部分
-func TestGetDefaultAvatar_Logic(t *testing.T) {
+func TestUserServiceImpl_Register(t *testing.T) {
+	// 准备依赖
+	userRepo := NewMockUserRepository()
+	configRepo := NewMockSystemConfigRepository()
+	jwtService := auth.NewJWTService("secret", 1)
+	logger := zap.NewNop()
+
+	// 初始化Service
+	// 注意：redisClient 传入 nil，因为 Register 方法中没有使用 redis
+	userService := NewUserService(userRepo, configRepo, jwtService, nil, logger)
+
+	// 测试用例
 	tests := []struct {
-		name           string
-		configExists   bool
-		configValue    string
-		expectedResult string
+		name       string
+		username   string
+		password   string
+		email      string
+		avatar     string
+		wantErr    bool
+		errMsg     string
+		setupMocks func()
 	}{
 		{
-			name:           "配置存在时返回配置值",
-			configExists:   true,
-			configValue:    "https://example.com/avatar.png",
-			expectedResult: "https://example.com/avatar.png",
+			name:     "正常注册",
+			username: "testuser",
+			password: "password123",
+			email:    "test@example.com",
+			avatar:   "",
+			wantErr:  false,
 		},
 		{
-			name:           "配置不存在时返回错误信息",
-			configExists:   false,
-			configValue:    "",
-			expectedResult: "数据库中不存在默认头像配置",
+			name:     "用户名已存在",
+			username: "existinguser",
+			password: "password123",
+			email:    "new@example.com",
+			avatar:   "",
+			wantErr:  true,
+			errMsg:   "用户名已存在",
+			setupMocks: func() {
+				userRepo.Create(&model.User{
+					Username: "existinguser",
+					Email:    "old@example.com",
+				})
+			},
+		},
+		{
+			name:     "邮箱已存在",
+			username: "newuser",
+			password: "password123",
+			email:    "existing@example.com",
+			avatar:   "",
+			wantErr:  true,
+			errMsg:   "邮箱已被注册",
+			setupMocks: func() {
+				userRepo.Create(&model.User{
+					Username: "otheruser",
+					Email:    "existing@example.com",
+				})
+			},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			// 这个测试只验证逻辑，不实际调用repository
-			// 实际的repository调用测试需要集成测试或mock
-			if tt.configExists {
-				if tt.expectedResult != tt.configValue {
-					t.Errorf("当配置存在时，应该返回配置值")
+			// 重置mock状态
+			if tt.setupMocks != nil {
+				tt.setupMocks()
+			}
+
+			user, token, err := userService.Register(tt.username, tt.password, tt.email, tt.avatar)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Error("期望返回错误，但实际没有错误")
+					return
+				}
+				if tt.errMsg != "" && err.Error() != tt.errMsg {
+					t.Errorf("错误信息不匹配: got %v, want %v", err.Error(), tt.errMsg)
 				}
 			} else {
-				if !strings.Contains(tt.expectedResult, "数据库中不存在默认头像配置") {
-					t.Errorf("当配置不存在时，应该返回错误信息")
+				if err != nil {
+					t.Errorf("不期望返回错误: %v", err)
+					return
+				}
+				if user == nil {
+					t.Error("返回的用户不应为nil")
+				}
+				if token == "" {
+					t.Error("返回的Token不应为空")
+				}
+				if user.Username != tt.username {
+					t.Errorf("用户名不匹配: got %v, want %v", user.Username, tt.username)
 				}
 			}
 		})
 	}
 }
 
-// TestLoginUser_EmailDetection 测试登录时邮箱检测逻辑
-func TestLoginUser_EmailDetection(t *testing.T) {
+func TestUserServiceImpl_Login(t *testing.T) {
+	// 准备依赖
+	userRepo := NewMockUserRepository()
+	configRepo := NewMockSystemConfigRepository()
+	jwtService := auth.NewJWTService("secret", 1)
+	logger := zap.NewNop()
+
+	// 预置用户
+	password := "password123"
+	hashedPassword, _ := auth.HashPassword(password)
+	testUser := &model.User{
+		Username: "testlogin",
+		Email:    "login@example.com",
+		Password: hashedPassword,
+		Status:   1,
+	}
+	userRepo.Create(testUser)
+
+	userService := NewUserService(userRepo, configRepo, jwtService, nil, logger)
+
 	tests := []struct {
 		name            string
 		usernameOrEmail string
-		isEmail         bool
+		password        string
+		wantErr         bool
+		errMsg          string
 	}{
 		{
-			name:            "包含@符号，识别为邮箱",
-			usernameOrEmail: "user@example.com",
-			isEmail:         true,
+			name:            "用户名登录成功",
+			usernameOrEmail: "testlogin",
+			password:        "password123",
+			wantErr:         false,
 		},
 		{
-			name:            "不包含@符号，识别为用户名",
-			usernameOrEmail: "username",
-			isEmail:         false,
+			name:            "邮箱登录成功",
+			usernameOrEmail: "login@example.com",
+			password:        "password123",
+			wantErr:         false,
 		},
 		{
-			name:            "空字符串",
-			usernameOrEmail: "",
-			isEmail:         false,
+			name:            "密码错误",
+			usernameOrEmail: "testlogin",
+			password:        "wrongpassword",
+			wantErr:         true,
+			errMsg:          "用户名/邮箱或密码错误",
 		},
 		{
-			name:            "只有@符号",
-			usernameOrEmail: "@",
-			isEmail:         true,
+			name:            "用户不存在",
+			usernameOrEmail: "nonexistent",
+			password:        "password123",
+			wantErr:         true,
+			errMsg:          "用户名/邮箱或密码错误",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			isEmail := strings.Contains(tt.usernameOrEmail, "@")
-			if isEmail != tt.isEmail {
-				t.Errorf("Email detection failed: got %v, want %v", isEmail, tt.isEmail)
+			user, token, err := userService.Login(tt.usernameOrEmail, tt.password, "127.0.0.1", "test-agent")
+
+			if tt.wantErr {
+				if err == nil {
+					t.Error("期望返回错误，但实际没有错误")
+				} else if tt.errMsg != "" && err.Error() != tt.errMsg {
+					t.Errorf("错误信息不匹配: got %v, want %v", err.Error(), tt.errMsg)
+				}
+			} else {
+				if err != nil {
+					t.Errorf("不期望返回错误: %v", err)
+				}
+				if user == nil {
+					t.Error("用户不应为nil")
+				}
+				if token == "" {
+					t.Error("Token不应为空")
+				}
 			}
 		})
 	}
 }
 
-// TestUserService_Constants 测试用户服务相关常量
-func TestUserService_Constants(t *testing.T) {
-	// 测试默认用户角色
-	defaultRole := "user"
-	if defaultRole == "" {
-		t.Error("默认用户角色不能为空")
+// TestUserServiceImpl_BasicGetters 测试 GetByID / GetByEmail / UpdateInfo / UpdateAvatar
+func TestUserServiceImpl_BasicGettersAndUpdates(t *testing.T) {
+	userRepo := NewMockUserRepository()
+	configRepo := NewMockSystemConfigRepository()
+	jwtService := auth.NewJWTService("secret", 1)
+	logger := zap.NewNop()
+
+	// 预置用户
+	user := &model.User{
+		ID:       1,
+		Username: "basic",
+		Email:    "basic@example.com",
+		Avatar:   "",
+	}
+	userRepo.Create(user)
+
+	userService := NewUserService(userRepo, configRepo, jwtService, nil, logger)
+
+	// GetByID
+	gotByID, err := userService.GetByID(1)
+	if err != nil || gotByID == nil || gotByID.ID != 1 {
+		t.Fatalf("GetByID 返回不正确: user=%+v, err=%v", gotByID, err)
 	}
 
-	// 测试默认用户状态
-	defaultStatus := int16(1)
-	if defaultStatus != 1 {
-		t.Errorf("默认用户状态应为1（正常），实际为%d", defaultStatus)
+	// GetByEmail
+	gotByEmail, err := userService.GetByEmail("basic@example.com")
+	if err != nil || gotByEmail == nil || gotByEmail.Email != "basic@example.com" {
+		t.Fatalf("GetByEmail 返回不正确: user=%+v, err=%v", gotByEmail, err)
 	}
 
-	// 测试初始积分
-	initialPoints := 0
-	if initialPoints < 0 {
-		t.Errorf("初始积分不应为负数，实际为%d", initialPoints)
+	// UpdateInfo
+	user.Username = "updated"
+	if err := userService.UpdateInfo(user); err != nil {
+		t.Fatalf("UpdateInfo 失败: %v", err)
+	}
+	updated, _ := userRepo.FindByID(1)
+	if updated.Username != "updated" {
+		t.Fatalf("UpdateInfo 未更新用户名, got=%s", updated.Username)
+	}
+
+	// UpdateAvatar 只需确认不会返回错误（具体字段更新由仓库层保证）
+	if err := userService.UpdateAvatar(1, "http://example.com/avatar.png"); err != nil {
+		t.Fatalf("UpdateAvatar 失败: %v", err)
 	}
 }
 
-// TestUserService_Validation 测试用户数据验证逻辑
-func TestUserService_Validation(t *testing.T) {
+// TestUserServiceImpl_ChangePassword 测试 ChangePassword
+func TestUserServiceImpl_ChangePassword(t *testing.T) {
+	userRepo := NewMockUserRepository()
+	configRepo := NewMockSystemConfigRepository()
+	jwtService := auth.NewJWTService("secret", 1)
+	logger := zap.NewNop()
+
+	hashed, _ := auth.HashPassword("oldpass")
+	user := &model.User{
+		ID:       1,
+		Username: "changepw",
+		Password: hashed,
+	}
+	userRepo.Create(user)
+
+	userService := NewUserService(userRepo, configRepo, jwtService, nil, logger)
+
+	// 原密码正确
+	if err := userService.ChangePassword(1, "oldpass", "newpass"); err != nil {
+		t.Fatalf("ChangePassword 正常情况失败: %v", err)
+	}
+
+	// 用户不存在
+	if err := userService.ChangePassword(999, "oldpass", "newpass"); err == nil {
+		t.Fatalf("ChangePassword 应在用户不存在时返回错误")
+	}
+
+	// 原密码错误
+	if err := userService.ChangePassword(1, "wrong", "another"); err == nil {
+		t.Fatalf("ChangePassword 应在原密码错误时返回错误")
+	}
+}
+
+// TestUserServiceImpl_ResetPassword 测试 ResetPassword
+func TestUserServiceImpl_ResetPassword(t *testing.T) {
+	userRepo := NewMockUserRepository()
+	configRepo := NewMockSystemConfigRepository()
+	jwtService := auth.NewJWTService("secret", 1)
+	logger := zap.NewNop()
+
+	user := &model.User{
+		ID:       1,
+		Username: "resetpw",
+		Email:    "reset@example.com",
+	}
+	userRepo.Create(user)
+
+	userService := NewUserService(userRepo, configRepo, jwtService, nil, logger)
+
+	// 正常重置
+	if err := userService.ResetPassword("reset@example.com", "newpass"); err != nil {
+		t.Fatalf("ResetPassword 正常情况失败: %v", err)
+	}
+
+	// 用户不存在
+	if err := userService.ResetPassword("notfound@example.com", "newpass"); err == nil {
+		t.Fatalf("ResetPassword 应在用户不存在时返回错误")
+	}
+}
+
+// TestUserServiceImpl_ChangeEmail 测试 ChangeEmail
+func TestUserServiceImpl_ChangeEmail(t *testing.T) {
+	userRepo := NewMockUserRepository()
+	configRepo := NewMockSystemConfigRepository()
+	jwtService := auth.NewJWTService("secret", 1)
+	logger := zap.NewNop()
+
+	user1 := &model.User{ID: 1, Email: "user1@example.com"}
+	user2 := &model.User{ID: 2, Email: "user2@example.com"}
+	userRepo.Create(user1)
+	userRepo.Create(user2)
+
+	userService := NewUserService(userRepo, configRepo, jwtService, nil, logger)
+
+	// 正常修改
+	if err := userService.ChangeEmail(1, "new@example.com"); err != nil {
+		t.Fatalf("ChangeEmail 正常情况失败: %v", err)
+	}
+
+	// 邮箱被其他用户占用
+	if err := userService.ChangeEmail(1, "user2@example.com"); err == nil {
+		t.Fatalf("ChangeEmail 应在邮箱被占用时返回错误")
+	}
+}
+
+// TestUserServiceImpl_ValidateAvatarURL 测试 ValidateAvatarURL
+func TestUserServiceImpl_ValidateAvatarURL(t *testing.T) {
+	userRepo := NewMockUserRepository()
+	configRepo := NewMockSystemConfigRepository()
+	jwtService := auth.NewJWTService("secret", 1)
+	logger := zap.NewNop()
+
+	userService := NewUserService(userRepo, configRepo, jwtService, nil, logger)
+
 	tests := []struct {
-		name      string
-		username  string
-		email     string
-		password  string
-		wantValid bool
+		name    string
+		url     string
+		wantErr bool
 	}{
-		{
-			name:      "有效的用户名和邮箱",
-			username:  "testuser",
-			email:     "test@example.com",
-			password:  "password123",
-			wantValid: true,
-		},
-		{
-			name:      "用户名为空",
-			username:  "",
-			email:     "test@example.com",
-			password:  "password123",
-			wantValid: false,
-		},
-		{
-			name:      "邮箱为空",
-			username:  "testuser",
-			email:     "",
-			password:  "password123",
-			wantValid: false,
-		},
-		{
-			name:      "密码为空",
-			username:  "testuser",
-			email:     "test@example.com",
-			password:  "",
-			wantValid: false,
-		},
-		{
-			name:      "邮箱格式无效（缺少@）",
-			username:  "testuser",
-			email:     "invalid-email",
-			password:  "password123",
-			wantValid: false,
-		},
+		{"空字符串通过", "", false},
+		{"相对路径通过", "/images/avatar.png", false},
+		{"非法URL格式", "://bad-url", true},
+		{"非法协议", "ftp://example.com/avatar.png", true},
+		{"缺少主机名", "http:///avatar.png", true},
+		{"本地域名通过", "http://localhost/avatar.png", false},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			// 简单的验证逻辑测试
-			isValid := tt.username != "" && tt.email != "" && tt.password != "" && strings.Contains(tt.email, "@")
-			if isValid != tt.wantValid {
-				t.Errorf("Validation failed: got %v, want %v", isValid, tt.wantValid)
+			err := userService.ValidateAvatarURL(tt.url)
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("ValidateAvatarURL(%q) error = %v, wantErr=%v", tt.url, err, tt.wantErr)
 			}
 		})
 	}
 }
 
-// TestUserService_AvatarLogic 测试头像逻辑
-func TestUserService_AvatarLogic(t *testing.T) {
-	tests := []struct {
-		name           string
-		providedAvatar string
-		defaultAvatar  string
-		expectedAvatar string
-	}{
-		{
-			name:           "提供头像时使用提供的头像",
-			providedAvatar: "https://example.com/custom.png",
-			defaultAvatar:  "https://example.com/default.png",
-			expectedAvatar: "https://example.com/custom.png",
-		},
-		{
-			name:           "未提供头像时使用默认头像",
-			providedAvatar: "",
-			defaultAvatar:  "https://example.com/default.png",
-			expectedAvatar: "https://example.com/default.png",
-		},
+// TestUserServiceImpl_MaxLimits 测试 GetMaxProfilesPerUser / GetMaxTexturesPerUser
+func TestUserServiceImpl_MaxLimits(t *testing.T) {
+	userRepo := NewMockUserRepository()
+	configRepo := NewMockSystemConfigRepository()
+	jwtService := auth.NewJWTService("secret", 1)
+	logger := zap.NewNop()
+
+	// 未配置时走默认值
+	userService := NewUserService(userRepo, configRepo, jwtService, nil, logger)
+	if got := userService.GetMaxProfilesPerUser(); got != 5 {
+		t.Fatalf("GetMaxProfilesPerUser 默认值错误, got=%d", got)
+	}
+	if got := userService.GetMaxTexturesPerUser(); got != 50 {
+		t.Fatalf("GetMaxTexturesPerUser 默认值错误, got=%d", got)
 	}
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			avatarURL := tt.providedAvatar
-			if avatarURL == "" {
-				avatarURL = tt.defaultAvatar
-			}
-			if avatarURL != tt.expectedAvatar {
-				t.Errorf("Avatar logic failed: got %s, want %s", avatarURL, tt.expectedAvatar)
-			}
-		})
+	// 配置有效值
+	configRepo.Update(&model.SystemConfig{Key: "max_profiles_per_user", Value: "10"})
+	configRepo.Update(&model.SystemConfig{Key: "max_textures_per_user", Value: "100"})
+
+	if got := userService.GetMaxProfilesPerUser(); got != 10 {
+		t.Fatalf("GetMaxProfilesPerUser 配置值错误, got=%d", got)
 	}
-}
+	if got := userService.GetMaxTexturesPerUser(); got != 100 {
+		t.Fatalf("GetMaxTexturesPerUser 配置值错误, got=%d", got)
+	}
+}