backend/internal/pkg/crypto/batch_decrypt_test.go

package crypto

import (
	"encoding/json"
	"fmt"
	"testing"
)

// BenchmarkEncryptDecryptSingle 单条加密解密性能基准
func BenchmarkEncryptDecryptSingle(b *testing.B) {
	key := "12345678901234567890123456789012"
	_ = InitMessageEncryptor(key, 1)
	encryptor := GetMessageEncryptor()

	plaintext := []byte(`{"type":"text","data":{"content":"这是一条测试消息"}}`)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ciphertext, _ := encryptor.Encrypt(plaintext)
		_, _ = encryptor.Decrypt(ciphertext)
	}
}

// BenchmarkSerialDecrypt 串行解密性能基准（对比用）
func BenchmarkSerialDecrypt(b *testing.B) {
	key := "12345678901234567890123456789012"
	_ = InitMessageEncryptor(key, 1)
	encryptor := GetMessageEncryptor()

	sizes := []int{10, 50, 100, 500}

	for _, size := range sizes {
		b.Run(fmt.Sprintf("size_%d", size), func(b *testing.B) {
			ciphertexts := make([]string, size)
			for i := 0; i < size; i++ {
				msg := map[string]interface{}{
					"type": "text",
					"data": map[string]string{"content": fmt.Sprintf("消息内容 %d", i)},
				}
				plaintext, _ := json.Marshal(msg)
				ciphertexts[i], _ = encryptor.Encrypt(plaintext)
			}

			b.ResetTimer()
			for i := 0; i < b.N; i++ {
				for _, ct := range ciphertexts {
					_, _ = encryptor.Decrypt(ct)
				}
			}
		})
	}
}

// BenchmarkBatchDecrypt 批量并行解密性能基准
func BenchmarkBatchDecrypt(b *testing.B) {
	key := "12345678901234567890123456789012"
	_ = InitMessageEncryptor(key, 1)
	encryptor := GetMessageEncryptor()

	sizes := []int{10, 50, 100, 500}

	for _, size := range sizes {
		b.Run(fmt.Sprintf("size_%d", size), func(b *testing.B) {
			// 生成加密数据
			ciphertexts := make([]string, size)
			for i := 0; i < size; i++ {
				msg := map[string]interface{}{
					"type": "text",
					"data": map[string]string{"content": fmt.Sprintf("消息内容 %d", i)},
				}
				plaintext, _ := json.Marshal(msg)
				ciphertexts[i], _ = encryptor.Encrypt(plaintext)
			}

			b.ResetTimer()
			for i := 0; i < b.N; i++ {
				_ = encryptor.BatchDecrypt(ciphertexts, 4)
			}
		})
	}
}

// TestBatchDecrypt 验证批量解密与单条解密结果一致
func TestBatchDecrypt(t *testing.T) {
	key := "12345678901234567890123456789012"
	_ = InitMessageEncryptor(key, 1)
	encryptor := GetMessageEncryptor()

	count := 100
	ciphertexts := make([]string, count)
	expectedContents := make([]string, count)

	for i := 0; i < count; i++ {
		content := fmt.Sprintf("测试消息 %d", i)
		expectedContents[i] = content
		msg := fmt.Sprintf(`{"type":"text","data":{"content":"%s"}}`, content)
		ciphertext, err := encryptor.Encrypt([]byte(msg))
		if err != nil {
			t.Fatalf("Encrypt failed: %v", err)
		}
		ciphertexts[i] = ciphertext
	}

	// 批量解密
	results := encryptor.BatchDecrypt(ciphertexts, 4)

	if len(results) != count {
		t.Fatalf("BatchDecrypt returned %d results, want %d", len(results), count)
	}

	// 验证结果
	for i, result := range results {
		if result == nil {
			t.Errorf("Decrypt result[%d] is nil", i)
			continue
		}

		var msg map[string]interface{}
		if err := json.Unmarshal(result, &msg); err != nil {
			t.Errorf("Unmarshal result[%d] failed: %v", i, err)
			continue
		}

		data, ok := msg["data"].(map[string]interface{})
		if !ok {
			t.Errorf("result[%d] data is not map", i)
			continue
		}

		content, ok := data["content"].(string)
		if !ok {
			t.Errorf("result[%d] content is not string", i)
			continue
		}

		if content != expectedContents[i] {
			t.Errorf("result[%d] content = %s, want %s", i, content, expectedContents[i])
		}
	}
}