backend/internal/service/profile_service_test.go

package service

import (
	"testing"
)

// TestProfileService_Validation 测试Profile服务验证逻辑
func TestProfileService_Validation(t *testing.T) {
	tests := []struct {
		name        string
		userID      int64
		profileName string
		wantValid   bool
	}{
		{
			name:        "有效的用户ID和角色名",
			userID:      1,
			profileName: "TestProfile",
			wantValid:   true,
		},
		{
			name:        "用户ID为0时无效",
			userID:      0,
			profileName: "TestProfile",
			wantValid:   false,
		},
		{
			name:        "角色名为空时无效",
			userID:      1,
			profileName: "",
			wantValid:   false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isValid := tt.userID > 0 && tt.profileName != ""
			if isValid != tt.wantValid {
				t.Errorf("Validation failed: got %v, want %v", isValid, tt.wantValid)
			}
		})
	}
}

// TestProfileService_StatusValidation 测试用户状态验证
func TestProfileService_StatusValidation(t *testing.T) {
	tests := []struct {
		name      string
		status    int16
		wantValid bool
	}{
		{
			name:      "状态为1（正常）时有效",
			status:    1,
			wantValid: true,
		},
		{
			name:      "状态为0（禁用）时无效",
			status:    0,
			wantValid: false,
		},
		{
			name:      "状态为-1（删除）时无效",
			status:    -1,
			wantValid: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isValid := tt.status == 1
			if isValid != tt.wantValid {
				t.Errorf("Status validation failed: got %v, want %v", isValid, tt.wantValid)
			}
		})
	}
}

// TestProfileService_IsActiveDefault 测试Profile默认活跃状态
func TestProfileService_IsActiveDefault(t *testing.T) {
	// 新创建的档案默认为活跃状态
	isActive := true
	if !isActive {
		t.Error("新创建的Profile应该默认为活跃状态")
	}
}

// TestUpdateProfile_PermissionCheck 测试更新Profile的权限检查逻辑
func TestUpdateProfile_PermissionCheck(t *testing.T) {
	tests := []struct {
		name          string
		profileUserID int64
		requestUserID int64
		wantErr       bool
	}{
		{
			name:          "用户ID匹配，允许操作",
			profileUserID: 1,
			requestUserID: 1,
			wantErr:       false,
		},
		{
			name:          "用户ID不匹配，拒绝操作",
			profileUserID: 1,
			requestUserID: 2,
			wantErr:       true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			hasError := tt.profileUserID != tt.requestUserID
			if hasError != tt.wantErr {
				t.Errorf("Permission check failed: got %v, want %v", hasError, tt.wantErr)
			}
		})
	}
}

// TestUpdateProfile_NameValidation 测试更新Profile时名称验证逻辑
func TestUpdateProfile_NameValidation(t *testing.T) {
	tests := []struct {
		name        string
		currentName string
		newName     *string
		shouldCheck bool
	}{
		{
			name:        "名称未改变，不检查",
			currentName: "TestProfile",
			newName:     stringPtr("TestProfile"),
			shouldCheck: false,
		},
		{
			name:        "名称改变，需要检查",
			currentName: "TestProfile",
			newName:     stringPtr("NewProfile"),
			shouldCheck: true,
		},
		{
			name:        "名称为nil，不检查",
			currentName: "TestProfile",
			newName:     nil,
			shouldCheck: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			shouldCheck := tt.newName != nil && *tt.newName != tt.currentName
			if shouldCheck != tt.shouldCheck {
				t.Errorf("Name validation check failed: got %v, want %v", shouldCheck, tt.shouldCheck)
			}
		})
	}
}

// TestDeleteProfile_PermissionCheck 测试删除Profile的权限检查
func TestDeleteProfile_PermissionCheck(t *testing.T) {
	tests := []struct {
		name          string
		profileUserID int64
		requestUserID int64
		wantErr       bool
	}{
		{
			name:          "用户ID匹配，允许删除",
			profileUserID: 1,
			requestUserID: 1,
			wantErr:       false,
		},
		{
			name:          "用户ID不匹配，拒绝删除",
			profileUserID: 1,
			requestUserID: 2,
			wantErr:       true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			hasError := tt.profileUserID != tt.requestUserID
			if hasError != tt.wantErr {
				t.Errorf("Permission check failed: got %v, want %v", hasError, tt.wantErr)
			}
		})
	}
}

// TestSetActiveProfile_PermissionCheck 测试设置活跃Profile的权限检查
func TestSetActiveProfile_PermissionCheck(t *testing.T) {
	tests := []struct {
		name          string
		profileUserID int64
		requestUserID int64
		wantErr       bool
	}{
		{
			name:          "用户ID匹配，允许设置",
			profileUserID: 1,
			requestUserID: 1,
			wantErr:       false,
		},
		{
			name:          "用户ID不匹配，拒绝设置",
			profileUserID: 1,
			requestUserID: 2,
			wantErr:       true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			hasError := tt.profileUserID != tt.requestUserID
			if hasError != tt.wantErr {
				t.Errorf("Permission check failed: got %v, want %v", hasError, tt.wantErr)
			}
		})
	}
}

// TestCheckProfileLimit_Logic 测试Profile数量限制检查逻辑
func TestCheckProfileLimit_Logic(t *testing.T) {
	tests := []struct {
		name        string
		count       int
		maxProfiles int
		wantErr     bool
	}{
		{
			name:        "未达到上限",
			count:       5,
			maxProfiles: 10,
			wantErr:     false,
		},
		{
			name:        "达到上限",
			count:       10,
			maxProfiles: 10,
			wantErr:     true,
		},
		{
			name:        "超过上限",
			count:       15,
			maxProfiles: 10,
			wantErr:     true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			hasError := tt.count >= tt.maxProfiles
			if hasError != tt.wantErr {
				t.Errorf("Limit check failed: got %v, want %v", hasError, tt.wantErr)
			}
		})
	}
}

// TestValidateProfileByUserID_InputValidation 测试ValidateProfileByUserID输入验证
func TestValidateProfileByUserID_InputValidation(t *testing.T) {
	tests := []struct {
		name    string
		userID  int64
		uuid    string
		wantErr bool
	}{
		{
			name:    "有效输入",
			userID:  1,
			uuid:    "test-uuid",
			wantErr: false,
		},
		{
			name:    "userID为0",
			userID:  0,
			uuid:    "test-uuid",
			wantErr: true,
		},
		{
			name:    "uuid为空",
			userID:  1,
			uuid:    "",
			wantErr: true,
		},
		{
			name:    "两者都无效",
			userID:  0,
			uuid:    "",
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			hasError := tt.userID == 0 || tt.uuid == ""
			if hasError != tt.wantErr {
				t.Errorf("Input validation failed: got %v, want %v", hasError, tt.wantErr)
			}
		})
	}
}

// TestValidateProfileByUserID_UserIDMatching 测试用户ID匹配逻辑
func TestValidateProfileByUserID_UserIDMatching(t *testing.T) {
	tests := []struct {
		name          string
		profileUserID int64
		requestUserID int64
		wantValid     bool
	}{
		{
			name:          "用户ID匹配",
			profileUserID: 1,
			requestUserID: 1,
			wantValid:     true,
		},
		{
			name:          "用户ID不匹配",
			profileUserID: 1,
			requestUserID: 2,
			wantValid:     false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isValid := tt.profileUserID == tt.requestUserID
			if isValid != tt.wantValid {
				t.Errorf("UserID matching failed: got %v, want %v", isValid, tt.wantValid)
			}
		})
	}
}

// TestGenerateRSAPrivateKey 测试RSA私钥生成
func TestGenerateRSAPrivateKey(t *testing.T) {
	tests := []struct {
		name      string
		wantError bool
	}{
		{
			name:      "生成RSA私钥",
			wantError: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			privateKey, err := generateRSAPrivateKey()
			if (err != nil) != tt.wantError {
				t.Errorf("generateRSAPrivateKey() error = %v, wantError %v", err, tt.wantError)
				return
			}
			if !tt.wantError {
				if privateKey == "" {
					t.Error("generateRSAPrivateKey() 返回的私钥不应为空")
				}
				// 验证PEM格式
				if len(privateKey) < 100 {
					t.Errorf("generateRSAPrivateKey() 返回的私钥长度异常: %d", len(privateKey))
				}
				// 验证包含PEM头部
				if !contains(privateKey, "BEGIN RSA PRIVATE KEY") {
					t.Error("generateRSAPrivateKey() 返回的私钥应包含PEM头部")
				}
			}
		})
	}
}

// TestGenerateRSAPrivateKey_Uniqueness 测试RSA私钥唯一性
func TestGenerateRSAPrivateKey_Uniqueness(t *testing.T) {
	keys := make(map[string]bool)
	for i := 0; i < 10; i++ {
		key, err := generateRSAPrivateKey()
		if err != nil {
			t.Fatalf("generateRSAPrivateKey() 失败: %v", err)
		}
		if keys[key] {
			t.Errorf("第%d次生成的密钥与之前重复", i+1)
		}
		keys[key] = true
	}
}

// 辅助函数
func stringPtr(s string) *string {
	return &s
}

func contains(s, substr string) bool {
	return len(s) >= len(substr) && (s == substr ||
		(len(s) > len(substr) && (s[:len(substr)] == substr ||
			s[len(s)-len(substr):] == substr ||
			containsMiddle(s, substr))))
}

func containsMiddle(s, substr string) bool {
	for i := 0; i <= len(s)-len(substr); i++ {
		if s[i:i+len(substr)] == substr {
			return true
		}
	}
	return false
}