bopx/api_test.go

package bopx_test

import (
	"context"
	"testing"

	"code.yun.ink/pkg/bopx"
	"github.com/stretchr/testify/assert"
)

// TestApiGetSign 测试API签名生成
func TestApiGetSign(t *testing.T) {
	// 测试用例1: 基本参数签名
	params := map[string]interface{}{
		"name": "huang",
		"age":  18,
	}

	api := bopx.NewApi()
	sign, err := api.GetSign(context.Background(), "huangxinyun", params)
	if err != nil {
		t.Errorf("GetSign returned error: %v", err)
	}

	expectedSign := "F84C5DF671D8279B57AC6EED2C140407" // 根据算法计算得出的预期值
	if sign != expectedSign {
		t.Errorf("GetSign() = %v, want %v", sign, expectedSign)
	}

	// 记录生成的签名值
	t.Logf("Generated sign: %s", sign)
}

// TestApiVerify 测试API签名验证
func TestApiVerify(t *testing.T) {
	// 测试用例1: 正确签名验证
	params := map[string]interface{}{
		"name": "huang",
		"age":  18,
	}

	api := bopx.NewApi()
	sign, err := api.GetSign(context.Background(), "huangxinyun", params)
	if err != nil {
		t.Errorf("GetSign returned error: %v", err)
	}

	params["sign"] = sign
	err = api.Verify(context.Background(), "huangxinyun", params)
	if err != nil {
		t.Errorf("Verify returned error: %v", err)
	}

	// 测试用例2: 签名参数不存在
	paramsWithoutSign := map[string]interface{}{
		"name": "huang",
		"age":  18,
	}

	err = api.Verify(context.Background(), "huangxinyun", paramsWithoutSign)
	if err != bopx.ErrorSignParamNotExist {
		t.Errorf("Verify should return ErrorSignParamNotExist, got: %v", err)
	}

	// 测试用例3: 签名参数不是字符串
	paramsWithInvalidSign := map[string]interface{}{
		"name": "huang",
		"age":  18,
		"sign": 12345, // 非字符串类型
	}

	err = api.Verify(context.Background(), "huangxinyun", paramsWithInvalidSign)
	if err != bopx.ErrorSignMustBeString {
		t.Errorf("Verify should return ErrorSignMustBeString, got: %v", err)
	}

	// 测试用例4: 签名不匹配
	paramsWithWrongSign := map[string]interface{}{
		"name": "huang",
		"age":  18,
		"sign": "WRONGSIGN",
	}

	err = api.Verify(context.Background(), "huangxinyun", paramsWithWrongSign)
	if err != bopx.ErrorSignFail {
		t.Errorf("Verify should return ErrorSignFail, got: %v", err)
	}
}

// TestApiIgnoreKeys 测试忽略键功能
func TestApiIgnoreKeys(t *testing.T) {
	params := map[string]interface{}{
		"name":         "huang",
		"age":          18,
		"platform_key": "ignored",
		"sign":         "ignored",
		"key":          "ignored",
	}

	api := bopx.NewApi(bopx.WithIgnoreKeys("platform_key", "sign", "key"))
	sign, err := api.GetSign(context.Background(), "huangxinyun", params)
	if err != nil {
		t.Errorf("GetSign returned error: %v", err)
	}

	// 验证忽略的键不影响签名结果
	paramsWithoutIgnored := map[string]interface{}{
		"name": "huang",
		"age":  18,
	}

	signWithoutIgnored, err := api.GetSign(context.Background(), "huangxinyun", paramsWithoutIgnored)
	if err != nil {
		t.Errorf("GetSign returned error: %v", err)
	}

	if sign != signWithoutIgnored {
		t.Errorf("Signatures with/without ignored keys should be equal. With ignored: %s, without: %s", sign, signWithoutIgnored)
	}
}

// TestApiEmptyParams 测试空参数
func TestApiEmptyParams(t *testing.T) {
	params := map[string]interface{}{}

	api := bopx.NewApi(bopx.WithIgnoreKeys("platform_key", "sign", "key"))
	sign, err := api.GetSign(context.Background(), "huangxinyun", params)

	assert.NotNil(t, err)

	assert.Equal(t, bopx.ErrorSignParamIsEmpty, err)
	assert.Equal(t, "", sign)

}

// TestApiSpecialValues 测试特殊值
func TestApiSpecialValues(t *testing.T) {
	params := map[string]interface{}{
		"empty_string":  "",
		"nil_value":     nil,
		"zero":          0,
		"special_chars": "!@#$%^&*()_+-=[]{}|;':\",./<>?",
	}

	api := bopx.NewApi(bopx.WithIgnoreKeys("platform_key", "sign", "key"))
	sign, err := api.GetSign(context.Background(), "testkey", params)
	if err != nil {
		t.Errorf("GetSign returned error: %v", err)
	}

	if sign == "" {
		t.Error("Sign should not be empty for special values")
	}

	params["sign"] = sign
	err = api.Verify(context.Background(), "testkey", params)
	if err != nil {
		t.Errorf("Verify returned error: %v", err)
	}
}

// TestApiConsistentResults 测试签名一致性
func TestApiConsistentResults(t *testing.T) {
	params1 := map[string]interface{}{
		"c": "third",
		"a": "first",
		"b": "second",
	}

	params2 := map[string]interface{}{
		"b": "second",
		"c": "third",
		"a": "first",
	}

	api := bopx.NewApi()

	sign1, err := api.GetSign(context.Background(), "consistentkey", params1)
	if err != nil {
		t.Errorf("GetSign for params1 returned error: %v", err)
	}

	sign2, err := api.GetSign(context.Background(), "consistentkey", params2)
	if err != nil {
		t.Errorf("GetSign for params2 returned error: %v", err)
	}

	// 由于参数排序，两种不同顺序的map应该产生相同的签名
	if sign1 != sign2 {
		t.Errorf("Signatures should be consistent regardless of parameter order. sign1: %s, sign2: %s", sign1, sign2)
	}
}