xlgo-core/test/test.go

package test

import (
	"bytes"
	"encoding/json"
	"errors"
	"io"
	"mime/multipart"
	"net/http"
	"net/http/httptest"
	"sync"
	"testing"

	"github.com/gin-gonic/gin"
)

// SetupRouter 创建不带框架默认中间件的测试路由。
//
// 需要 RequestID、Recover、超时等框架中间件的集成测试，应直接构造 xlgo.App
// 或手动 Use 对应中间件。
func SetupRouter() *gin.Engine {
	gin.SetMode(gin.TestMode)
	return gin.New()
}

// Request 是测试请求构造器。
type Request struct {
	router  *gin.Engine
	method  string
	path    string
	body    any
	headers map[string]string
}

// NewRequest 创建测试请求。
func NewRequest(router *gin.Engine, method, path string) *Request {
	return &Request{
		router:  router,
		method:  method,
		path:    path,
		headers: make(map[string]string),
	}
}

// GET 创建 GET 请求。
func GET(router *gin.Engine, path string) *Request {
	return NewRequest(router, http.MethodGet, path)
}

// POST 创建 POST 请求。
func POST(router *gin.Engine, path string) *Request {
	return NewRequest(router, http.MethodPost, path)
}

// PUT 创建 PUT 请求。
func PUT(router *gin.Engine, path string) *Request {
	return NewRequest(router, http.MethodPut, path)
}

// DELETE 创建 DELETE 请求。
func DELETE(router *gin.Engine, path string) *Request {
	return NewRequest(router, http.MethodDelete, path)
}

// PATCH 创建 PATCH 请求。
func PATCH(router *gin.Engine, path string) *Request {
	return NewRequest(router, http.MethodPatch, path)
}

// WithBody 设置请求体。
func (r *Request) WithBody(body any) *Request {
	r.body = body
	return r
}

// WithJSON 设置 JSON 请求体并写入 Content-Type。
func (r *Request) WithJSON(body any) *Request {
	r.body = body
	r.headers["Content-Type"] = "application/json"
	return r
}

// WithHeader 设置请求头。
func (r *Request) WithHeader(key, value string) *Request {
	r.headers[key] = value
	return r
}

// WithToken 设置 Authorization Bearer token。
func (r *Request) WithToken(token string) *Request {
	r.headers["Authorization"] = "Bearer " + token
	return r
}

// Execute 执行请求并返回带断言方法的响应包装。
func (r *Request) Execute() *Response {
	return &Response{ResponseRecorder: r.ExecuteRecorder()}
}

// ExecuteRecorder 执行请求并返回原始 httptest.ResponseRecorder。
func (r *Request) ExecuteRecorder() *httptest.ResponseRecorder {
	var bodyReader *bytes.Reader
	if r.body != nil {
		bodyBytes, _ := json.Marshal(r.body)
		bodyReader = bytes.NewReader(bodyBytes)
	} else {
		bodyReader = bytes.NewReader(nil)
	}

	req := httptest.NewRequest(r.method, r.path, bodyReader)
	for key, value := range r.headers {
		req.Header.Set(key, value)
	}

	recorder := httptest.NewRecorder()
	r.router.ServeHTTP(recorder, req)
	return recorder
}

// Response 是测试响应辅助包装。
type Response struct {
	*httptest.ResponseRecorder
}

// ParseJSON 解析 JSON 响应。
func (r *Response) ParseJSON(v any) error {
	return json.Unmarshal(r.Body.Bytes(), v)
}

// AssertStatus 断言 HTTP 状态码。
func (r *Response) AssertStatus(t *testing.T, expected int) {
	t.Helper()
	if r.Code != expected {
		t.Errorf("状态码错误: 期望 %d, 实际 %d", expected, r.Code)
	}
}

// AssertOK 断言状态码为 200。
func (r *Response) AssertOK(t *testing.T) {
	t.Helper()
	r.AssertStatus(t, http.StatusOK)
}

// AssertCreated 断言状态码为 201。
func (r *Response) AssertCreated(t *testing.T) {
	t.Helper()
	r.AssertStatus(t, http.StatusCreated)
}

// AssertBadRequest 断言状态码为 400。
func (r *Response) AssertBadRequest(t *testing.T) {
	t.Helper()
	r.AssertStatus(t, http.StatusBadRequest)
}

// AssertUnauthorized 断言状态码为 401。
func (r *Response) AssertUnauthorized(t *testing.T) {
	t.Helper()
	r.AssertStatus(t, http.StatusUnauthorized)
}

// AssertForbidden 断言状态码为 403。
func (r *Response) AssertForbidden(t *testing.T) {
	t.Helper()
	r.AssertStatus(t, http.StatusForbidden)
}

// AssertNotFound 断言状态码为 404。
func (r *Response) AssertNotFound(t *testing.T) {
	t.Helper()
	r.AssertStatus(t, http.StatusNotFound)
}

// AssertJSONContains 断言 JSON 响应包含指定字段和值，支持 data.user.id 形式的嵌套键。
func (r *Response) AssertJSONContains(t *testing.T, key string, expected any) {
	t.Helper()

	var result map[string]any
	if err := r.ParseJSON(&result); err != nil {
		t.Errorf("解析 JSON 失败: %v", err)
		return
	}

	keys := splitKey(key)
	current := result
	for i, k := range keys {
		if i == len(keys)-1 {
			if current[k] != expected {
				t.Errorf("JSON 字段 %s 错误: 期望 %v, 实际 %v", key, expected, current[k])
			}
			return
		}

		next, ok := current[k].(map[string]any)
		if !ok {
			t.Errorf("JSON 字段 %s 不是对象", k)
			return
		}
		current = next
	}
}

func splitKey(key string) []string {
	var keys []string
	start := 0
	for i := 0; i < len(key); i++ {
		if key[i] == '.' {
			keys = append(keys, key[start:i])
			start = i + 1
		}
	}
	keys = append(keys, key[start:])
	return keys
}

// MockDB 是并发安全的简单内存数据库 mock。
type MockDB struct {
	mu   sync.RWMutex
	data map[any]any
}

// NewMockDB 创建模拟数据库。
func NewMockDB() *MockDB {
	return &MockDB{data: make(map[any]any)}
}

// Set 设置数据。
func (m *MockDB) Set(key, value any) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.data[key] = value
}

// Get 获取数据。
func (m *MockDB) Get(key any) (any, bool) {
	m.mu.RLock()
	defer m.mu.RUnlock()
	v, ok := m.data[key]
	return v, ok
}

// Delete 删除数据。
func (m *MockDB) Delete(key any) {
	m.mu.Lock()
	defer m.mu.Unlock()
	delete(m.data, key)
}

// Clear 清空数据。
func (m *MockDB) Clear() {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.data = make(map[any]any)
}

// MockCache 是并发安全的简单内存缓存 mock。
type MockCache struct {
	mu   sync.RWMutex
	data map[string][]byte
}

// NewMockCache 创建模拟缓存。
func NewMockCache() *MockCache {
	return &MockCache{data: make(map[string][]byte)}
}

// Set 设置缓存，内部会复制 value，避免调用方后续修改污染 mock。
func (m *MockCache) Set(key string, value []byte) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.data[key] = append([]byte(nil), value...)
}

// Get 获取缓存，返回值会复制一份，避免调用方修改内部状态。
func (m *MockCache) Get(key string) ([]byte, bool) {
	m.mu.RLock()
	defer m.mu.RUnlock()
	v, ok := m.data[key]
	return append([]byte(nil), v...), ok
}

// Delete 删除缓存。
func (m *MockCache) Delete(key string) {
	m.mu.Lock()
	defer m.mu.Unlock()
	delete(m.data, key)
}

// Exists 检查缓存是否存在。
func (m *MockCache) Exists(key string) bool {
	m.mu.RLock()
	defer m.mu.RUnlock()
	_, ok := m.data[key]
	return ok
}

// Clear 清空缓存。
func (m *MockCache) Clear() {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.data = make(map[string][]byte)
}

// ErrMockStorageTooLarge 表示 mock storage 收到超过内存保护上限的内容。
var ErrMockStorageTooLarge = errors.New("mock storage: 文件超过大小限制")

const mockStorageMaxBytes int64 = 32 << 20

// MockStorage 是并发安全的简单内存存储 mock。
type MockStorage struct {
	mu    sync.RWMutex
	files map[string][]byte
	urls  map[string]string
}

// NewMockStorage 创建模拟存储。
func NewMockStorage() *MockStorage {
	return &MockStorage{
		files: make(map[string][]byte),
		urls:  make(map[string]string),
	}
}

// Upload 模拟上传，签名对齐 storage.Upload。
func (m *MockStorage) Upload(file *multipart.FileHeader, subdir string) (string, error) {
	if file == nil {
		return "", errors.New("mock storage: 文件不能为空")
	}
	if file.Size > mockStorageMaxBytes {
		return "", ErrMockStorageTooLarge
	}

	data, err := file.Open()
	if err != nil {
		return "", err
	}
	b, err := io.ReadAll(io.LimitReader(data, mockStorageMaxBytes+1))
	if cerr := data.Close(); cerr != nil {
		err = errors.Join(err, cerr)
	}
	if err != nil {
		return "", err
	}
	if int64(len(b)) > mockStorageMaxBytes {
		return "", ErrMockStorageTooLarge
	}

	path := "/mock/" + subdir + "/" + file.Filename
	m.mu.Lock()
	defer m.mu.Unlock()
	m.files[path] = b
	return path, nil
}

// UploadFromBytes 模拟字节上传，签名对齐 storage.UploadFromBytes。
func (m *MockStorage) UploadFromBytes(data []byte, filename, subdir string) (string, error) {
	if int64(len(data)) > mockStorageMaxBytes {
		return "", ErrMockStorageTooLarge
	}
	path := "/mock/" + subdir + "/" + filename
	m.mu.Lock()
	defer m.mu.Unlock()
	m.files[path] = append([]byte(nil), data...)
	return path, nil
}

// GetURL 获取 mock URL。
func (m *MockStorage) GetURL(path string) string {
	return "http://mock.test" + path
}

// AssertEqual 断言相等。
func AssertEqual(t *testing.T, expected, actual any) {
	t.Helper()
	if expected != actual {
		t.Errorf("不相等: 期望 %v, 实际 %v", expected, actual)
	}
}

// AssertNotNil 断言非空。
func AssertNotNil(t *testing.T, value any) {
	t.Helper()
	if value == nil {
		t.Error("期望非空，实际为空")
	}
}

// AssertNil 断言为空。
func AssertNil(t *testing.T, value any) {
	t.Helper()
	if value != nil {
		t.Errorf("期望为空，实际为: %v", value)
	}
}

// AssertTrue 断言为 true。
func AssertTrue(t *testing.T, value bool) {
	t.Helper()
	if !value {
		t.Error("期望为 true，实际为 false")
	}
}

// AssertFalse 断言为 false。
func AssertFalse(t *testing.T, value bool) {
	t.Helper()
	if value {
		t.Error("期望为 false，实际为 true")
	}
}

// AssertError 断言有错误。
func AssertError(t *testing.T, err error) {
	t.Helper()
	if err == nil {
		t.Error("期望有错误，实际无错误")
	}
}

// AssertNoError 断言无错误。
func AssertNoError(t *testing.T, err error) {
	t.Helper()
	if err != nil {
		t.Errorf("期望无错误，实际错误: %v", err)
	}
}