250 lines
9.6 KiB
Go
250 lines
9.6 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"affiliate_dash/internal/model"
|
|
)
|
|
|
|
func newImportAllMock(t *testing.T, packages []map[string]interface{}, details map[string]map[string]interface{}) *httptest.Server {
|
|
t.Helper()
|
|
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
switch {
|
|
case r.URL.Path == "/api/user/packages":
|
|
_ = json.NewEncoder(w).Encode(map[string]interface{}{
|
|
"packages": packages,
|
|
"pagination": map[string]interface{}{
|
|
"page": 1, "pageSize": 100, "total": len(packages), "totalPages": 1,
|
|
},
|
|
})
|
|
case strings.HasPrefix(r.URL.Path, "/api/package/"):
|
|
code := strings.TrimPrefix(r.URL.Path, "/api/package/")
|
|
detail, ok := details[code]
|
|
if !ok {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
_, _ = w.Write([]byte(`{"error":"package not found"}`))
|
|
return
|
|
}
|
|
_ = json.NewEncoder(w).Encode(detail)
|
|
default:
|
|
w.WriteHeader(http.StatusNotFound)
|
|
}
|
|
}))
|
|
}
|
|
|
|
func TestIsUnboundRockToken(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
token RockPackageToken
|
|
expect bool
|
|
}{
|
|
{"两个绑定字段都为空", RockPackageToken{BindChangedAt: "", BindChangeType: ""}, true},
|
|
{"有 bind_changed_at", RockPackageToken{BindChangedAt: "2026-10-30 16:02:19", BindChangeType: ""}, false},
|
|
{"bind 类型", RockPackageToken{BindChangedAt: "", BindChangeType: "bind"}, false},
|
|
{"rebind 类型", RockPackageToken{BindChangedAt: "", BindChangeType: "rebind"}, false},
|
|
{"两者都有", RockPackageToken{BindChangedAt: "2026-10-30 16:02:19", BindChangeType: "rebind"}, false},
|
|
}
|
|
for _, tc := range cases {
|
|
if got := isUnboundRockToken(tc.token); got != tc.expect {
|
|
t.Fatalf("%s: isUnboundRockToken=%v, want %v", tc.name, got, tc.expect)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestImportAllUpstreamPackages_SkipsImported(t *testing.T) {
|
|
db := newRockTestDB(t)
|
|
packages := []map[string]interface{}{
|
|
{"id": 100, "token_count": 1, "share_code": "share-100", "status": "active", "created_at": "2026-10-20 10:00:00", "note": "a"},
|
|
{"id": 101, "token_count": 1, "share_code": "share-101", "status": "active", "created_at": "2026-10-21 10:00:00", "note": "b"},
|
|
}
|
|
details := map[string]map[string]interface{}{
|
|
"share-101": {
|
|
"package": map[string]interface{}{"id": 101, "share_code": "share-101", "token_count": 1, "status": "active"},
|
|
"tokens": []map[string]interface{}{
|
|
{"id": 95001, "token": "tk-95001", "color": "black", "region": "Q/V可用", "status": "using", "redeem_code": "rc-95001"},
|
|
},
|
|
},
|
|
}
|
|
server := newImportAllMock(t, packages, details)
|
|
defer server.Close()
|
|
|
|
pid := int64(100)
|
|
if err := db.Create(&model.RockToken{
|
|
UpstreamTokenID: "90001",
|
|
Token: "tk-90001",
|
|
RedeemCode: "rc-90001",
|
|
Status: model.RockStatusAvailable,
|
|
PackageID: &pid,
|
|
}).Error; err != nil {
|
|
t.Fatalf("写入本地 Token 失败: %v", err)
|
|
}
|
|
|
|
svc := NewRockService(db, NewRockClient(server.URL))
|
|
setRockTestBearer(t, svc, "bearer-test")
|
|
|
|
result, err := svc.ImportAllUpstreamPackages(context.Background(), 50, 1)
|
|
if err != nil {
|
|
t.Fatalf("全量导入失败: %v", err)
|
|
}
|
|
if result.Scanned != 2 || result.Skipped != 1 || result.Imported != 1 {
|
|
t.Fatalf("汇总不符: %+v", result)
|
|
}
|
|
if result.TokensImported != 1 {
|
|
t.Fatalf("应导入 1 个 Token，实际 %d", result.TokensImported)
|
|
}
|
|
|
|
var token model.RockToken
|
|
if err := db.Where("upstream_token_id = ?", "95001").First(&token).Error; err != nil {
|
|
t.Fatalf("查询导入 Token 失败: %v", err)
|
|
}
|
|
if token.Status != model.RockStatusAvailable {
|
|
t.Fatalf("导入后应为 available，实际 %s", token.Status)
|
|
}
|
|
}
|
|
|
|
func TestImportAllUpstreamPackages_FiltersBoundTokens(t *testing.T) {
|
|
db := newRockTestDB(t)
|
|
packages := []map[string]interface{}{
|
|
{"id": 300, "token_count": 3, "share_code": "share-300", "status": "active", "created_at": "2026-10-22 10:00:00", "note": "c"},
|
|
}
|
|
details := map[string]map[string]interface{}{
|
|
"share-300": {
|
|
"package": map[string]interface{}{"id": 300, "share_code": "share-300", "token_count": 3, "status": "active"},
|
|
"tokens": []map[string]interface{}{
|
|
{"id": 96001, "token": "tk-96001", "color": "black", "region": "Q/V可用", "status": "using", "redeem_code": "rc-96001"},
|
|
{"id": 96002, "token": "tk-96002", "color": "black", "region": "Q/V可用", "status": "bound", "redeem_code": "rc-96002", "bind_changed_at": "2026-10-30 16:02:19", "bind_change_type": "bind", "bound_account": "角色A", "bound_account_id": "111"},
|
|
{"id": 96003, "token": "tk-96003", "color": "black", "region": "Q/V可用", "status": "redeemed", "redeem_code": "rc-96003", "bind_changed_at": "2026-10-31 12:45:06", "bind_change_type": "rebind", "bound_account": "角色B", "bound_account_id": "222"},
|
|
},
|
|
},
|
|
}
|
|
server := newImportAllMock(t, packages, details)
|
|
defer server.Close()
|
|
|
|
svc := NewRockService(db, NewRockClient(server.URL))
|
|
setRockTestBearer(t, svc, "bearer-test")
|
|
|
|
result, err := svc.ImportAllUpstreamPackages(context.Background(), 50, 1)
|
|
if err != nil {
|
|
t.Fatalf("全量导入失败: %v", err)
|
|
}
|
|
if result.Imported != 1 || result.TokensImported != 1 {
|
|
t.Fatalf("应只导入 1 个未绑定 Token，实际 %+v", result)
|
|
}
|
|
if result.TokensSkippedBound != 2 {
|
|
t.Fatalf("应跳过 2 个已绑定 Token，实际 %d", result.TokensSkippedBound)
|
|
}
|
|
|
|
var count int64
|
|
db.Model(&model.RockToken{}).Where("upstream_token_id IN ?", []string{"96002", "96003"}).Count(&count)
|
|
if count != 0 {
|
|
t.Fatalf("已绑定 Token 不应入库，实际 %d 条", count)
|
|
}
|
|
|
|
var token model.RockToken
|
|
if err := db.Where("upstream_token_id = ?", "96001").First(&token).Error; err != nil {
|
|
t.Fatalf("查询导入 Token 失败: %v", err)
|
|
}
|
|
if token.Status != model.RockStatusAvailable || token.UsingAt != nil || token.BoundAt != nil {
|
|
t.Fatalf("导入结果不符: status=%s usingAt=%v boundAt=%v", token.Status, token.UsingAt, token.BoundAt)
|
|
}
|
|
}
|
|
|
|
func TestImportAllUpstreamPackages_EmptyWhenAllBound(t *testing.T) {
|
|
db := newRockTestDB(t)
|
|
packages := []map[string]interface{}{
|
|
{"id": 310, "token_count": 1, "share_code": "share-310", "status": "active", "created_at": "2026-10-22 10:00:00", "note": "d"},
|
|
}
|
|
details := map[string]map[string]interface{}{
|
|
"share-310": {
|
|
"package": map[string]interface{}{"id": 310, "share_code": "share-310", "token_count": 1, "status": "active"},
|
|
"tokens": []map[string]interface{}{
|
|
{"id": 97001, "token": "tk-97001", "color": "black", "region": "Q/V可用", "status": "bound", "redeem_code": "rc-97001", "bind_changed_at": "2026-10-30 16:02:19", "bind_change_type": "bind"},
|
|
},
|
|
},
|
|
}
|
|
server := newImportAllMock(t, packages, details)
|
|
defer server.Close()
|
|
|
|
svc := NewRockService(db, NewRockClient(server.URL))
|
|
setRockTestBearer(t, svc, "bearer-test")
|
|
|
|
result, err := svc.ImportAllUpstreamPackages(context.Background(), 50, 1)
|
|
if err != nil {
|
|
t.Fatalf("全量导入失败: %v", err)
|
|
}
|
|
if result.Empty != 1 || result.Imported != 0 {
|
|
t.Fatalf("全部已绑定时应记为 empty，实际 %+v", result)
|
|
}
|
|
}
|
|
|
|
func TestImportAllUpstreamPackages_PartialFailure(t *testing.T) {
|
|
db := newRockTestDB(t)
|
|
packages := []map[string]interface{}{
|
|
{"id": 400, "token_count": 1, "share_code": "share-400", "status": "active", "created_at": "2026-10-23 10:00:00", "note": "e"},
|
|
{"id": 401, "token_count": 1, "share_code": "share-401", "status": "active", "created_at": "2026-10-24 10:00:00", "note": "f"},
|
|
}
|
|
details := map[string]map[string]interface{}{
|
|
"share-401": {
|
|
"package": map[string]interface{}{"id": 401, "share_code": "share-401", "token_count": 1, "status": "active"},
|
|
"tokens": []map[string]interface{}{
|
|
{"id": 98001, "token": "tk-98001", "color": "black", "region": "Q/V可用", "status": "using", "redeem_code": "rc-98001"},
|
|
},
|
|
},
|
|
}
|
|
server := newImportAllMock(t, packages, details)
|
|
defer server.Close()
|
|
|
|
svc := NewRockService(db, NewRockClient(server.URL))
|
|
setRockTestBearer(t, svc, "bearer-test")
|
|
|
|
result, err := svc.ImportAllUpstreamPackages(context.Background(), 50, 1)
|
|
if err != nil {
|
|
t.Fatalf("全量导入调用失败: %v", err)
|
|
}
|
|
if result.Failed != 1 || result.Imported != 1 {
|
|
t.Fatalf("应 1 失败 1 成功，实际 %+v", result)
|
|
}
|
|
if len(result.Results) != 2 || result.Results[0].Error == "" {
|
|
t.Fatalf("失败包应带错误信息: %+v", result.Results)
|
|
}
|
|
}
|
|
|
|
func TestImportAllUpstreamPackages_MaxPackages(t *testing.T) {
|
|
db := newRockTestDB(t)
|
|
packages := []map[string]interface{}{
|
|
{"id": 500, "token_count": 1, "share_code": "share-500", "status": "active", "created_at": "2026-10-25 10:00:00", "note": "g"},
|
|
{"id": 501, "token_count": 1, "share_code": "share-501", "status": "active", "created_at": "2026-10-26 10:00:00", "note": "h"},
|
|
{"id": 502, "token_count": 1, "share_code": "share-502", "status": "active", "created_at": "2026-10-27 10:00:00", "note": "i"},
|
|
}
|
|
details := map[string]map[string]interface{}{
|
|
"share-500": {
|
|
"package": map[string]interface{}{"id": 500, "share_code": "share-500", "token_count": 1, "status": "active"},
|
|
"tokens": []map[string]interface{}{
|
|
{"id": 99001, "token": "tk-99001", "color": "black", "region": "Q/V可用", "status": "using", "redeem_code": "rc-99001"},
|
|
},
|
|
},
|
|
}
|
|
server := newImportAllMock(t, packages, details)
|
|
defer server.Close()
|
|
|
|
svc := NewRockService(db, NewRockClient(server.URL))
|
|
setRockTestBearer(t, svc, "bearer-test")
|
|
|
|
result, err := svc.ImportAllUpstreamPackages(context.Background(), 1, 1)
|
|
if err != nil {
|
|
t.Fatalf("全量导入失败: %v", err)
|
|
}
|
|
if result.Remaining != 2 {
|
|
t.Fatalf("上限 1 时应剩余 2 个包，实际 %d", result.Remaining)
|
|
}
|
|
if len(result.Results) != 1 {
|
|
t.Fatalf("应只处理 1 个包，实际 %d", len(result.Results))
|
|
}
|
|
}
|