371 lines
13 KiB
Go
371 lines
13 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/topfans/backend/pkg/models"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// setupPeripheralTestData helper: 准备测试用 asset + 可选 peripheral_info
|
|
// ★ 使用包内共享 helper(createTestStar / createTestUser / createTestAsset),
|
|
//
|
|
// 资源会自动被 cleanupTestDB 通过 mobile LIKE '199%' / identity_id LIKE 'test_peripheral_%' 清理
|
|
// (star identity_id "test_peripheral_asset" 匹配 cleanupTestDB 的 test_asset_% 规则)
|
|
func setupPeripheralTestData(t *testing.T, db *gorm.DB, withPeripheralInfo bool) int64 {
|
|
t.Helper()
|
|
|
|
star := createTestStar(t, db, "test_peripheral_asset")
|
|
user := createTestUser(t, db, "19900009001")
|
|
asset := createTestAsset(t, db, user.ID, star.StarID, "test_peripheral_asset")
|
|
|
|
if withPeripheralInfo {
|
|
// peripheral_info 用 raw SQL INSERT(避开任何潜在的 GORM 钩子)
|
|
if err := db.Exec(`INSERT INTO peripheral_info (asset_id, star_id, user_id, code, image, brand, company, hash, verifier, first_verified_at, created_at, updated_at)
|
|
VALUES (?, 87, 0, 'PERI-2026-001', '', 'TopFans', '上海文化', '0xabc', '官方', 1715600000000, 1, 1)`,
|
|
asset.ID).Error; err != nil {
|
|
t.Fatalf("Failed to create test peripheral_info: %v", err)
|
|
}
|
|
}
|
|
|
|
return asset.ID
|
|
}
|
|
|
|
func TestPeripheralRepo_GetAssetForVerification_Exists(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
assetID := setupPeripheralTestData(t, db, false)
|
|
|
|
got, err := repo.GetAssetForVerification(context.Background(), assetID)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if got == nil {
|
|
t.Fatal("expected asset, got nil")
|
|
}
|
|
if got.ID != assetID {
|
|
t.Errorf("expected id=%d, got %d", assetID, got.ID)
|
|
}
|
|
}
|
|
|
|
func TestPeripheralRepo_GetAssetForVerification_NotFound(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
|
|
got, err := repo.GetAssetForVerification(context.Background(), 999999999999)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if got != nil {
|
|
t.Errorf("expected nil, got %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestPeripheralRepo_GetPeripheralInfo_Exists(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
assetID := setupPeripheralTestData(t, db, true)
|
|
|
|
got, err := repo.GetPeripheralInfo(context.Background(), assetID)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if got == nil {
|
|
t.Fatal("expected PeripheralInfo, got nil")
|
|
}
|
|
if got.Brand != "TopFans" {
|
|
t.Errorf("expected brand=TopFans, got %s", got.Brand)
|
|
}
|
|
}
|
|
|
|
func TestPeripheralRepo_GetPeripheralInfo_NotFound(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
|
|
got, err := repo.GetPeripheralInfo(context.Background(), 999999999999)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if got != nil {
|
|
t.Errorf("expected nil, got %+v", got)
|
|
}
|
|
}
|
|
|
|
// TestPeripheralRepo_GetPeripheralInfoByID_Exists 验证按 peripheral_info 主键 id 查到记录
|
|
// ★ 回归测试:2026-07-17 by-hash 接口 50003,根因是 GetPeripheralInfoByHash 错把 peripheral_info.id
|
|
//
|
|
// 传给 GetPeripheralInfo(asset_id 查),查不到。新增按 id 查的方法。
|
|
func TestPeripheralRepo_GetPeripheralInfoByID_Exists(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
setupPeripheralTestData(t, db, true) // 创建 peripheral_info
|
|
|
|
// 直接查 peripheral_info.id(setupPeripheralTestData 没返回这个值)
|
|
var peripheralID int64
|
|
if err := db.Raw(`SELECT id FROM peripheral_info WHERE code = 'PERI-2026-001' LIMIT 1`).Scan(&peripheralID).Error; err != nil {
|
|
t.Fatalf("query peripheral_info.id failed: %v", err)
|
|
}
|
|
if peripheralID == 0 {
|
|
t.Fatal("expected peripheral_info.id > 0, got 0")
|
|
}
|
|
|
|
got, err := repo.GetPeripheralInfoByID(context.Background(), peripheralID)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if got == nil {
|
|
t.Fatal("expected PeripheralInfo, got nil")
|
|
}
|
|
if got.ID != peripheralID {
|
|
t.Errorf("expected id=%d, got %d", peripheralID, got.ID)
|
|
}
|
|
if got.Brand != "TopFans" {
|
|
t.Errorf("expected brand=TopFans, got %s", got.Brand)
|
|
}
|
|
}
|
|
|
|
func TestPeripheralRepo_GetPeripheralInfoByID_NotFound(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
|
|
got, err := repo.GetPeripheralInfoByID(context.Background(), 999999999999)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if got != nil {
|
|
t.Errorf("expected nil, got %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestPeripheralRepo_GetPeripheralInfoByID_InvalidID(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
|
|
_, err := repo.GetPeripheralInfoByID(context.Background(), 0)
|
|
if err == nil {
|
|
t.Fatal("expected error for id=0, got nil")
|
|
}
|
|
}
|
|
|
|
// TestPeripheralRepo_ExistsRegistry_True 验证 ExistsRegistry 命中已有记录
|
|
func TestPeripheralRepo_ExistsRegistry_True(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
assetID := setupPeripheralTestData(t, db, false)
|
|
|
|
// 写入 1 条 asset_registry 记录(owner_uid=100)
|
|
db.Exec(`INSERT INTO asset_registry (owner_uid, asset_id, star_id, asset_type, status, created_at, updated_at)
|
|
VALUES (?, ?, 1, 'peripheral', 1, 1, 1)`, 100, assetID)
|
|
defer db.Exec("DELETE FROM asset_registry WHERE owner_uid = ? AND asset_id = ?", 100, assetID)
|
|
|
|
exists, err := repo.ExistsRegistry(context.Background(), 100, assetID, "peripheral")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if !exists {
|
|
t.Error("expected exists=true, got false")
|
|
}
|
|
}
|
|
|
|
// TestPeripheralRepo_ExistsRegistry_False 验证 ExistsRegistry 未命中时返 false
|
|
func TestPeripheralRepo_ExistsRegistry_False(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
assetID := setupPeripheralTestData(t, db, false)
|
|
|
|
// 不写入任何 registry 记录,查询应返 false
|
|
exists, err := repo.ExistsRegistry(context.Background(), 100, assetID, "peripheral")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if exists {
|
|
t.Error("expected exists=false, got true")
|
|
}
|
|
}
|
|
|
|
// TestPeripheralRepo_CountRecentMint 验证 CountRecentMint 仅统计 since 时间内的记录
|
|
func TestPeripheralRepo_CountRecentMint(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
star := createTestStar(t, db, "test_peripheral_count")
|
|
user := createTestUser(t, db, "19900009002")
|
|
// ★ 4 个 asset_id(3 条最近 + 1 条 25h 前),因 uk_registry_asset_type_id UNIQUE(asset_type, asset_id)
|
|
recentAsset1 := createTestAsset(t, db, user.ID, star.StarID, "test_peripheral_recent1")
|
|
recentAsset2 := createTestAsset(t, db, user.ID, star.StarID, "test_peripheral_recent2")
|
|
recentAsset3 := createTestAsset(t, db, user.ID, star.StarID, "test_peripheral_recent3")
|
|
oldAsset := createTestAsset(t, db, user.ID, star.StarID, "test_peripheral_old")
|
|
ownerUID := int64(101)
|
|
|
|
// 清理 owner_uid=101 的旧记录(避免别的测试残留影响)
|
|
db.Exec("DELETE FROM asset_registry WHERE owner_uid = ?", ownerUID)
|
|
|
|
// 3 条最近,1 条 25h 前
|
|
now := time.Now().UnixMilli()
|
|
db.Exec(`INSERT INTO asset_registry (owner_uid, asset_id, star_id, asset_type, status, created_at, updated_at)
|
|
VALUES (?, ?, ?, 'peripheral', 1, ?, ?), (?, ?, ?, 'peripheral', 1, ?, ?), (?, ?, ?, 'peripheral', 1, ?, ?)`,
|
|
ownerUID, recentAsset1.ID, star.StarID, now, now,
|
|
ownerUID, recentAsset2.ID, star.StarID, now, now,
|
|
ownerUID, recentAsset3.ID, star.StarID, now, now)
|
|
db.Exec(`INSERT INTO asset_registry (owner_uid, asset_id, star_id, asset_type, status, created_at, updated_at)
|
|
VALUES (?, ?, ?, 'peripheral', 1, ?, ?)`,
|
|
ownerUID, oldAsset.ID, star.StarID, now-25*3600*1000, now-25*3600*1000)
|
|
defer db.Exec("DELETE FROM asset_registry WHERE owner_uid = ?", ownerUID)
|
|
|
|
count, err := repo.CountRecentMint(context.Background(), ownerUID, "peripheral", 24*time.Hour)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if count != 3 {
|
|
t.Errorf("expected count=3, got %d", count)
|
|
}
|
|
}
|
|
|
|
// TestPeripheralRepo_InsertPeripheralRegistry verifies a peripheral registry row is inserted and returns generated fields.
|
|
func TestPeripheralRepo_InsertPeripheralRegistry(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
assetID := setupPeripheralTestData(t, db, false)
|
|
defer db.Where("asset_id = ?", assetID).Delete(&models.AssetRegistry{})
|
|
|
|
var asset models.Asset
|
|
if err := db.Select("id", "star_id").First(&asset, assetID).Error; err != nil {
|
|
t.Fatalf("query test asset failed: %v", err)
|
|
}
|
|
owner := createTestUser(t, db, "19900009003")
|
|
|
|
reg := &models.AssetRegistry{
|
|
OwnerUID: owner.ID,
|
|
AssetID: assetID,
|
|
StarID: asset.StarID,
|
|
AssetType: "peripheral",
|
|
Status: models.AssetRegistryStatusActive,
|
|
}
|
|
newID, createdAtMs, err := repo.InsertPeripheralRegistry(context.Background(), reg)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if newID <= 0 {
|
|
t.Errorf("expected newID > 0, got %d", newID)
|
|
}
|
|
if createdAtMs <= 0 {
|
|
t.Errorf("expected createdAtMs > 0, got %d", createdAtMs)
|
|
}
|
|
|
|
var got models.AssetRegistry
|
|
if err := db.First(&got, newID).Error; err != nil {
|
|
t.Fatalf("verify insert failed: %v", err)
|
|
}
|
|
if got.AssetType != "peripheral" {
|
|
t.Errorf("expected asset_type=peripheral, got %s", got.AssetType)
|
|
}
|
|
if got.AssetID != assetID {
|
|
t.Errorf("expected asset_id=%d, got %d", assetID, got.AssetID)
|
|
}
|
|
if got.OwnerUID != owner.ID {
|
|
t.Errorf("expected owner_uid=%d, got %d", owner.ID, got.OwnerUID)
|
|
}
|
|
}
|
|
|
|
// TestPeripheralRepo_RefreshVerifyCount verifies verify_count is refreshed from peripheral registry rows only.
|
|
func TestPeripheralRepo_RefreshVerifyCount(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
|
|
star := createTestStar(t, db, "test_asset_peripheral_refresh")
|
|
assetOwner := createTestUser(t, db, "19900009004")
|
|
asset := createTestAsset(t, db, assetOwner.ID, star.StarID, "test_asset_peripheral_refresh")
|
|
otherAsset := createTestAsset(t, db, assetOwner.ID, star.StarID, "test_asset_peripheral_refresh_other")
|
|
defer db.Where("asset_id IN ?", []int64{asset.ID, otherAsset.ID}).Delete(&models.AssetRegistry{})
|
|
|
|
registryOwner := createTestUser(t, db, "19900009005")
|
|
createRegistry := func(assetID int64, assetType string) {
|
|
t.Helper()
|
|
reg := &models.AssetRegistry{
|
|
OwnerUID: registryOwner.ID,
|
|
AssetID: assetID,
|
|
StarID: star.StarID,
|
|
AssetType: assetType,
|
|
Status: models.AssetRegistryStatusActive,
|
|
}
|
|
if err := db.Create(reg).Error; err != nil {
|
|
t.Fatalf("create test registry failed: %v", err)
|
|
}
|
|
}
|
|
createRegistry(asset.ID, "peripheral")
|
|
createRegistry(asset.ID, models.AssetTypeRegular)
|
|
createRegistry(otherAsset.ID, "peripheral")
|
|
|
|
if err := db.Table("assets").Where("id = ?", asset.ID).Update("verify_count", 99).Error; err != nil {
|
|
t.Fatalf("set stale verify_count failed: %v", err)
|
|
}
|
|
|
|
if err := repo.RefreshVerifyCount(context.Background(), asset.ID); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
var verifyCount int64
|
|
if err := db.Table("assets").Select("verify_count").Where("id = ?", asset.ID).Scan(&verifyCount).Error; err != nil {
|
|
t.Fatalf("query verify_count failed: %v", err)
|
|
}
|
|
if verifyCount != 1 {
|
|
t.Errorf("expected verify_count=1, got %d", verifyCount)
|
|
}
|
|
}
|
|
|
|
// TestPeripheralRepo_InsertPeripheralRegistry_Duplicate 验证并发插入触发 PG 唯一约束冲突时
|
|
//
|
|
// 返 sentinel ErrDuplicateRegistry(而非通用 PG 错误),
|
|
// 让 service 层能 errors.Is 识别并转 BizCodeAlreadyAdded (50004)。
|
|
func TestPeripheralRepo_InsertPeripheralRegistry_Duplicate(t *testing.T) {
|
|
db := setupTestDB(t)
|
|
defer cleanupTestDB(t, db)
|
|
repo := NewPeripheralRepository(db)
|
|
assetID := setupPeripheralTestData(t, db, false)
|
|
defer db.Where("asset_id = ?", assetID).Delete(&models.AssetRegistry{})
|
|
|
|
var asset models.Asset
|
|
if err := db.Select("id", "star_id").First(&asset, assetID).Error; err != nil {
|
|
t.Fatalf("query test asset failed: %v", err)
|
|
}
|
|
owner := createTestUser(t, db, "19900009006")
|
|
|
|
mkReg := func() *models.AssetRegistry {
|
|
return &models.AssetRegistry{
|
|
OwnerUID: owner.ID,
|
|
AssetID: assetID,
|
|
StarID: asset.StarID,
|
|
AssetType: "peripheral",
|
|
Status: models.AssetRegistryStatusActive,
|
|
}
|
|
}
|
|
|
|
// 第一次 INSERT 应成功
|
|
if _, _, err := repo.InsertPeripheralRegistry(context.Background(), mkReg()); err != nil {
|
|
t.Fatalf("first insert should succeed, got: %v", err)
|
|
}
|
|
|
|
// 第二次 INSERT 同 (owner_uid, star_id, asset_type, asset_id) 应触发 PG 23505
|
|
_, _, err := repo.InsertPeripheralRegistry(context.Background(), mkReg())
|
|
if err == nil {
|
|
t.Fatal("expected error on duplicate insert, got nil")
|
|
}
|
|
if !errors.Is(err, ErrDuplicateRegistry) {
|
|
t.Errorf("expected ErrDuplicateRegistry, got %v", err)
|
|
}
|
|
}
|