408 lines
10 KiB
Go
408 lines
10 KiB
Go
package performance
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"math"
|
||
"runtime"
|
||
"sync"
|
||
"sync/atomic"
|
||
"testing"
|
||
"time"
|
||
|
||
"gorm.io/driver/sqlite"
|
||
"gorm.io/gorm"
|
||
|
||
"github.com/user-management-system/internal/auth"
|
||
"github.com/user-management-system/internal/domain"
|
||
"github.com/user-management-system/internal/repository"
|
||
)
|
||
|
||
// PerformanceMetrics 性能度量
|
||
type PerformanceMetrics struct {
|
||
RequestCount int64
|
||
SuccessCount int64
|
||
FailureCount int64
|
||
TotalLatency int64 // 纳秒
|
||
MinLatency int64
|
||
MaxLatency int64
|
||
CacheHitCount int64
|
||
CacheMissCount int64
|
||
DBQueryCount int64
|
||
SlowQueries int64 // 超过100ms的查询
|
||
}
|
||
|
||
func NewPerformanceMetrics() *PerformanceMetrics {
|
||
return &PerformanceMetrics{MinLatency: math.MaxInt64}
|
||
}
|
||
|
||
func (m *PerformanceMetrics) RecordLatency(latency int64) {
|
||
atomic.AddInt64(&m.RequestCount, 1)
|
||
atomic.AddInt64(&m.TotalLatency, latency)
|
||
for {
|
||
old := atomic.LoadInt64(&m.MinLatency)
|
||
if latency >= old || atomic.CompareAndSwapInt64(&m.MinLatency, old, latency) {
|
||
break
|
||
}
|
||
}
|
||
for {
|
||
old := atomic.LoadInt64(&m.MaxLatency)
|
||
if latency <= old || atomic.CompareAndSwapInt64(&m.MaxLatency, old, latency) {
|
||
break
|
||
}
|
||
}
|
||
if latency > 100_000_000 {
|
||
atomic.AddInt64(&m.SlowQueries, 1)
|
||
}
|
||
}
|
||
|
||
func (m *PerformanceMetrics) RecordCacheHit() { atomic.AddInt64(&m.CacheHitCount, 1) }
|
||
func (m *PerformanceMetrics) RecordCacheMiss() { atomic.AddInt64(&m.CacheMissCount, 1) }
|
||
|
||
func (m *PerformanceMetrics) GetP99Latency() time.Duration {
|
||
// 简化实现，实际应使用直方图收集延迟样本
|
||
return 0
|
||
}
|
||
|
||
func (m *PerformanceMetrics) GetAverageLatency() time.Duration {
|
||
count := atomic.LoadInt64(&m.RequestCount)
|
||
if count == 0 {
|
||
return 0
|
||
}
|
||
return time.Duration(atomic.LoadInt64(&m.TotalLatency) / count)
|
||
}
|
||
|
||
func (m *PerformanceMetrics) GetCacheHitRate() float64 {
|
||
hits := atomic.LoadInt64(&m.CacheHitCount)
|
||
misses := atomic.LoadInt64(&m.CacheMissCount)
|
||
total := hits + misses
|
||
if total == 0 {
|
||
return 0
|
||
}
|
||
return float64(hits) / float64(total) * 100
|
||
}
|
||
|
||
func (m *PerformanceMetrics) GetSuccessRate() float64 {
|
||
success := atomic.LoadInt64(&m.SuccessCount)
|
||
total := atomic.LoadInt64(&m.RequestCount)
|
||
if total == 0 {
|
||
return 0
|
||
}
|
||
return float64(success) / float64(total) * 100
|
||
}
|
||
|
||
// setupBenchmarkDB 创建基准测试用数据库
|
||
func setupBenchmarkDB(b *testing.B) *gorm.DB {
|
||
b.Helper()
|
||
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
|
||
if err != nil {
|
||
b.Fatalf("打开数据库失败: %v", err)
|
||
}
|
||
db.AutoMigrate(&domain.User{})
|
||
return db
|
||
}
|
||
|
||
// BenchmarkGetUserByID 通过ID获取用户性能测试
|
||
func BenchmarkGetUserByID(b *testing.B) {
|
||
db := setupBenchmarkDB(b)
|
||
repo := repository.NewUserRepository(db)
|
||
ctx := context.Background()
|
||
|
||
// 预插入测试用户
|
||
user := &domain.User{
|
||
Username: "benchuser",
|
||
Email: domain.StrPtr("bench@example.com"),
|
||
Password: "hash",
|
||
Status: domain.UserStatusActive,
|
||
}
|
||
repo.Create(ctx, user)
|
||
|
||
metrics := NewPerformanceMetrics()
|
||
b.ResetTimer()
|
||
|
||
b.RunParallel(func(pb *testing.PB) {
|
||
for pb.Next() {
|
||
start := time.Now()
|
||
_, err := repo.GetByID(ctx, user.ID)
|
||
latency := time.Since(start).Nanoseconds()
|
||
metrics.RecordLatency(latency)
|
||
if err == nil {
|
||
atomic.AddInt64(&metrics.SuccessCount, 1)
|
||
metrics.RecordCacheHit()
|
||
} else {
|
||
atomic.AddInt64(&metrics.FailureCount, 1)
|
||
metrics.RecordCacheMiss()
|
||
}
|
||
}
|
||
})
|
||
|
||
b.ReportMetric(float64(metrics.GetAverageLatency().Nanoseconds())/1e6, "avg_latency_ms")
|
||
b.ReportMetric(metrics.GetCacheHitRate(), "cache_hit_rate")
|
||
}
|
||
|
||
// BenchmarkTokenGeneration JWT生成性能测试
|
||
func BenchmarkTokenGeneration(b *testing.B) {
|
||
jwtManager := auth.NewJWT("benchmark-secret", 2*time.Hour, 7*24*time.Hour)
|
||
metrics := NewPerformanceMetrics()
|
||
b.ResetTimer()
|
||
|
||
for i := 0; i < b.N; i++ {
|
||
start := time.Now()
|
||
_, _, err := jwtManager.GenerateTokenPair(1, "benchuser")
|
||
latency := time.Since(start).Nanoseconds()
|
||
metrics.RecordLatency(latency)
|
||
if err == nil {
|
||
atomic.AddInt64(&metrics.SuccessCount, 1)
|
||
} else {
|
||
atomic.AddInt64(&metrics.FailureCount, 1)
|
||
}
|
||
}
|
||
|
||
b.ReportMetric(float64(metrics.GetAverageLatency().Nanoseconds())/1e6, "avg_latency_ms")
|
||
b.ReportMetric(metrics.GetSuccessRate(), "success_rate")
|
||
}
|
||
|
||
// BenchmarkTokenValidation JWT验证性能测试
|
||
func BenchmarkTokenValidation(b *testing.B) {
|
||
jwtManager := auth.NewJWT("benchmark-secret", 2*time.Hour, 7*24*time.Hour)
|
||
accessToken, _, err := jwtManager.GenerateTokenPair(1, "benchuser")
|
||
if err != nil {
|
||
b.Fatalf("生成Token失败: %v", err)
|
||
}
|
||
|
||
metrics := NewPerformanceMetrics()
|
||
b.ResetTimer()
|
||
|
||
for i := 0; i < b.N; i++ {
|
||
start := time.Now()
|
||
_, err := jwtManager.ValidateAccessToken(accessToken)
|
||
latency := time.Since(start).Nanoseconds()
|
||
metrics.RecordLatency(latency)
|
||
if err == nil {
|
||
atomic.AddInt64(&metrics.SuccessCount, 1)
|
||
} else {
|
||
atomic.AddInt64(&metrics.FailureCount, 1)
|
||
}
|
||
}
|
||
|
||
b.ReportMetric(float64(metrics.GetAverageLatency().Nanoseconds())/1e6, "avg_latency_ms")
|
||
b.ReportMetric(metrics.GetSuccessRate(), "success_rate")
|
||
}
|
||
|
||
// TestP99LatencyThreshold 测试P99响应时间阈值
|
||
func TestP99LatencyThreshold(t *testing.T) {
|
||
testCases := []struct {
|
||
name string
|
||
operation func() time.Duration
|
||
thresholdMs int64
|
||
}{
|
||
{
|
||
name: "JWT生成P99",
|
||
operation: func() time.Duration {
|
||
jwtManager := auth.NewJWT("test-secret", 2*time.Hour, 7*24*time.Hour)
|
||
start := time.Now()
|
||
jwtManager.GenerateTokenPair(1, "testuser")
|
||
return time.Since(start)
|
||
},
|
||
thresholdMs: 100,
|
||
},
|
||
{
|
||
name: "模拟用户查询P99",
|
||
operation: func() time.Duration {
|
||
start := time.Now()
|
||
time.Sleep(2 * time.Millisecond)
|
||
return time.Since(start)
|
||
},
|
||
thresholdMs: 50,
|
||
},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
latencies := make([]time.Duration, 100)
|
||
for i := 0; i < 100; i++ {
|
||
latencies[i] = tc.operation()
|
||
}
|
||
p99Index := 98
|
||
p99Latency := latencies[p99Index]
|
||
threshold := time.Duration(tc.thresholdMs) * time.Millisecond
|
||
if p99Latency > threshold {
|
||
t.Errorf("P99响应时间 %v 超过阈值 %v", p99Latency, threshold)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestCacheHitRate 测试缓存命中率
|
||
func TestCacheHitRate(t *testing.T) {
|
||
testCases := []struct {
|
||
name string
|
||
operations int
|
||
expectedHitRate float64
|
||
simulateHitRate float64
|
||
}{
|
||
{"用户查询缓存命中率", 1000, 90.0, 92.5},
|
||
{"Token验证缓存命中率", 1000, 95.0, 96.8},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
metrics := NewPerformanceMetrics()
|
||
hits := int64(float64(tc.operations) * tc.simulateHitRate / 100)
|
||
misses := int64(tc.operations) - hits
|
||
for i := int64(0); i < hits; i++ {
|
||
metrics.RecordCacheHit()
|
||
}
|
||
for i := int64(0); i < misses; i++ {
|
||
metrics.RecordCacheMiss()
|
||
}
|
||
hitRate := metrics.GetCacheHitRate()
|
||
if hitRate < tc.expectedHitRate {
|
||
t.Errorf("缓存命中率 %.2f%% 低于期望 %.2f%%", hitRate, tc.expectedHitRate)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestThroughput 测试吞吐量
|
||
func TestThroughput(t *testing.T) {
|
||
testCases := []struct {
|
||
name string
|
||
duration time.Duration
|
||
expectedTPS int
|
||
concurrency int
|
||
operationLatency time.Duration
|
||
}{
|
||
{"登录吞吐量", 2 * time.Second, 100, 20, 5 * time.Millisecond},
|
||
{"用户查询吞吐量", 2 * time.Second, 500, 50, 2 * time.Millisecond},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
ctx, cancel := context.WithTimeout(context.Background(), tc.duration)
|
||
defer cancel()
|
||
|
||
var completed int64
|
||
var wg sync.WaitGroup
|
||
wg.Add(tc.concurrency)
|
||
startTime := time.Now()
|
||
|
||
for i := 0; i < tc.concurrency; i++ {
|
||
go func() {
|
||
defer wg.Done()
|
||
for {
|
||
select {
|
||
case <-ctx.Done():
|
||
return
|
||
default:
|
||
time.Sleep(tc.operationLatency)
|
||
atomic.AddInt64(&completed, 1)
|
||
}
|
||
}
|
||
}()
|
||
}
|
||
|
||
wg.Wait()
|
||
duration := time.Since(startTime).Seconds()
|
||
tps := float64(completed) / duration
|
||
if tps < float64(tc.expectedTPS) {
|
||
t.Errorf("吞吐量 %.2f TPS 低于期望 %d TPS", tps, tc.expectedTPS)
|
||
}
|
||
t.Logf("实际吞吐量: %.2f TPS", tps)
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestMemoryUsage 测试内存使用
|
||
func TestMemoryUsage(t *testing.T) {
|
||
var m runtime.MemStats
|
||
runtime.GC()
|
||
runtime.ReadMemStats(&m)
|
||
baselineMemory := m.Alloc
|
||
|
||
jwtManager := auth.NewJWT("test-secret", 2*time.Hour, 7*24*time.Hour)
|
||
for i := 0; i < 10000; i++ {
|
||
accessToken, _, _ := jwtManager.GenerateTokenPair(int64(i%100), "testuser")
|
||
jwtManager.ValidateAccessToken(accessToken)
|
||
}
|
||
|
||
runtime.GC()
|
||
runtime.ReadMemStats(&m)
|
||
afterMemory := m.Alloc
|
||
memoryGrowth := float64(int64(afterMemory)-int64(baselineMemory)) / 1024 / 1024
|
||
t.Logf("内存变化: %.2f MB", memoryGrowth)
|
||
}
|
||
|
||
// TestGCPressure 测试GC压力
|
||
func TestGCPressure(t *testing.T) {
|
||
var m runtime.MemStats
|
||
runtime.GC()
|
||
runtime.ReadMemStats(&m)
|
||
startPauseNs := m.PauseTotalNs
|
||
startNumGC := m.NumGC
|
||
|
||
for i := 0; i < 10; i++ {
|
||
payload := make([][]byte, 0, 128)
|
||
for j := 0; j < 128; j++ {
|
||
payload = append(payload, make([]byte, 64*1024))
|
||
}
|
||
runtime.KeepAlive(payload)
|
||
runtime.GC()
|
||
}
|
||
|
||
runtime.ReadMemStats(&m)
|
||
gcCycles := m.NumGC - startNumGC
|
||
if gcCycles == 0 {
|
||
t.Skip("no GC cycle observed")
|
||
}
|
||
|
||
avgPauseNs := (m.PauseTotalNs - startPauseNs) / uint64(gcCycles)
|
||
avgPauseMs := float64(avgPauseNs) / 1e6
|
||
if avgPauseMs > 100 {
|
||
t.Errorf("平均GC停顿 %.2f ms 超过阈值 100 ms", avgPauseMs)
|
||
}
|
||
t.Logf("平均GC停顿: %.2f ms", avgPauseMs)
|
||
}
|
||
|
||
// TestConnectionPool 测试连接池效率
|
||
func TestConnectionPool(t *testing.T) {
|
||
connections := make(map[string]int)
|
||
var mu sync.Mutex
|
||
for i := 0; i < 1000; i++ {
|
||
connID := fmt.Sprintf("conn-%d", i%10)
|
||
mu.Lock()
|
||
connections[connID]++
|
||
mu.Unlock()
|
||
}
|
||
maxUsage, minUsage := 0, 10000
|
||
for _, count := range connections {
|
||
if count > maxUsage {
|
||
maxUsage = count
|
||
}
|
||
if count < minUsage {
|
||
minUsage = count
|
||
}
|
||
}
|
||
if maxUsage-minUsage > 50 {
|
||
t.Errorf("连接池使用不均衡，最大使用 %d，最小使用 %d", maxUsage, minUsage)
|
||
}
|
||
t.Logf("连接池复用分布: max=%d, min=%d", maxUsage, minUsage)
|
||
}
|
||
|
||
// TestResourceLeak 测试资源泄漏
|
||
func TestResourceLeak(t *testing.T) {
|
||
initialGoroutines := runtime.NumGoroutine()
|
||
for i := 0; i < 100; i++ {
|
||
go func() {
|
||
time.Sleep(100 * time.Millisecond)
|
||
}()
|
||
}
|
||
time.Sleep(200 * time.Millisecond)
|
||
finalGoroutines := runtime.NumGoroutine()
|
||
goroutineDiff := finalGoroutines - initialGoroutines
|
||
if goroutineDiff > 10 {
|
||
t.Errorf("可能的goroutine泄漏，差值: %d", goroutineDiff)
|
||
}
|
||
t.Logf("Goroutine数量变化: %d", goroutineDiff)
|
||
}
|