perms-system-server/internal/model/productmember/sysProductMemberModel_test.go

package productmember

import (
	"context"
	"errors"
	"math/rand"
	"testing"
	"time"

	"perms-system-server/internal/testutil"

	"github.com/go-sql-driver/mysql"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
)

func randProductMemberUserId() int64 {
	return int64(900000 + rand.Intn(100000))
}

// TC-0310: 正常插入
func TestSysProductMemberModel_CRUD(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	data := &SysProductMember{
		ProductCode: pc,
		UserId:      userId,
		MemberType:  "MEMBER",
		Status:      1,
		CreateTime:  ts,
		UpdateTime:  ts,
	}
	res, err := m.Insert(ctx, data)
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, err := res.LastInsertId()
	if err != nil {
		t.Fatalf("LastInsertId: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_product_member", id)

	got, err := m.FindOne(ctx, id)
	if err != nil {
		t.Fatalf("FindOne: %v", err)
	}
	if got.ProductCode != pc || got.UserId != userId {
		t.Fatalf("FindOne mismatch: %+v", got)
	}

	byPair, err := m.FindOneByProductCodeUserId(ctx, pc, userId)
	if err != nil {
		t.Fatalf("FindOneByProductCodeUserId: %v", err)
	}
	if byPair.Id != id {
		t.Fatalf("FindOneByProductCodeUserId id want %d got %d", id, byPair.Id)
	}

	newTs := ts + 1
	got.Status = 2
	got.UpdateTime = newTs
	if err := m.Update(ctx, got); err != nil {
		t.Fatalf("Update: %v", err)
	}
	updated, err := m.FindOne(ctx, id)
	if err != nil {
		t.Fatalf("FindOne after update: %v", err)
	}
	if updated.Status != 2 || updated.UpdateTime != newTs {
		t.Fatalf("after Update: %+v", updated)
	}

	if err := m.Delete(ctx, id); err != nil {
		t.Fatalf("Delete: %v", err)
	}
	if _, err := m.FindOne(ctx, id); err != ErrNotFound {
		t.Fatalf("after Delete want ErrNotFound got %v", err)
	}
}

// TC-0475: 正常分页
func TestSysProductMemberModel_FindListByProductCode(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_page_" + testutil.UniqueId()
	ts := time.Now().Unix()

	var ids []int64
	for i := 0; i < 5; i++ {
		res, err := m.Insert(ctx, &SysProductMember{
			ProductCode: pc,
			UserId:      randProductMemberUserId(),
			MemberType:  "MEMBER",
			Status:      1,
			CreateTime:  ts,
			UpdateTime:  ts,
		})
		if err != nil {
			t.Fatalf("Insert: %v", err)
		}
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	defer func() {
		for _, id := range ids {
			testutil.CleanTable(ctx, conn, "sys_product_member", id)
		}
	}()

	list, total, err := m.FindListByProductCode(ctx, pc, 1, 2)
	if err != nil {
		t.Fatalf("page1: %v", err)
	}
	if total != 5 || len(list) != 2 {
		t.Fatalf("page1 total=%d len=%d", total, len(list))
	}
	list2, total2, err := m.FindListByProductCode(ctx, pc, 2, 2)
	if err != nil {
		t.Fatalf("page2: %v", err)
	}
	if total2 != 5 || len(list2) != 2 {
		t.Fatalf("page2 total=%d len=%d", total2, len(list2))
	}
	list3, total3, err := m.FindListByProductCode(ctx, pc, 3, 2)
	if err != nil {
		t.Fatalf("page3: %v", err)
	}
	if total3 != 5 || len(list3) != 1 {
		t.Fatalf("page3 total=%d len=%d", total3, len(list3))
	}
}

// TC-0477: 正常批量
func TestSysProductMemberModel_FindMapByProductCodeUserIds(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_map_" + testutil.UniqueId()
	u1, u2 := randProductMemberUserId(), randProductMemberUserId()
	uMissing := randProductMemberUserId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysProductMember{ProductCode: pc, UserId: u1, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysProductMember{ProductCode: pc, UserId: u2, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer func() {
		testutil.CleanTable(ctx, conn, "sys_product_member", id1, id2)
	}()

	empty, err := m.FindMapByProductCodeUserIds(ctx, pc, nil)
	if err != nil {
		t.Fatalf("empty nil: %v", err)
	}
	if len(empty) != 0 {
		t.Fatalf("empty nil want len 0 got %d", len(empty))
	}

	empty2, err := m.FindMapByProductCodeUserIds(ctx, pc, []int64{})
	if err != nil {
		t.Fatalf("empty slice: %v", err)
	}
	if len(empty2) != 0 {
		t.Fatalf("empty slice want len 0 got %d", len(empty2))
	}

	m1, err := m.FindMapByProductCodeUserIds(ctx, pc, []int64{u1, u2})
	if err != nil {
		t.Fatalf("normal: %v", err)
	}
	if len(m1) != 2 || m1[u1] == nil || m1[u2] == nil {
		t.Fatalf("normal map: %+v", m1)
	}

	m2, err := m.FindMapByProductCodeUserIds(ctx, pc, []int64{u1, uMissing})
	if err != nil {
		t.Fatalf("partial: %v", err)
	}
	if len(m2) != 1 || m2[u1] == nil || m2[uMissing] != nil {
		t.Fatalf("partial map: %+v", m2)
	}
}

// TC-0336: 多条记录(3条)
func TestSysProductMemberModel_BatchInsert(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_bi_" + testutil.UniqueId()
	u1, u2 := randProductMemberUserId(), randProductMemberUserId()
	ts := time.Now().Unix()

	list := []*SysProductMember{
		{Id: 930000001, ProductCode: pc, UserId: u1, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts},
		{Id: 930000002, ProductCode: pc, UserId: u2, MemberType: "ADMIN", Status: 1, CreateTime: ts, UpdateTime: ts},
	}
	if err := m.BatchInsert(ctx, list); err != nil {
		t.Fatalf("BatchInsert: %v", err)
	}
	var rows []struct {
		Id int64 `db:"id"`
	}
	q := "SELECT `id` FROM `sys_product_member` WHERE `productCode` = ? ORDER BY `id`"
	if err := conn.QueryRowsCtx(ctx, &rows, q, pc); err != nil {
		t.Fatalf("query: %v", err)
	}
	defer func() {
		for _, r := range rows {
			testutil.CleanTable(ctx, conn, "sys_product_member", r.Id)
		}
	}()
	if len(rows) != 2 {
		t.Fatalf("want 2 rows got %d", len(rows))
	}
}

// TC-0312: 唯一索引冲突
func TestSysProductMemberModel_DuplicateConstraint(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_dup_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysProductMember{ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_product_member", id)

	_, err = m.Insert(ctx, &SysProductMember{ProductCode: pc, UserId: userId, MemberType: "ADMIN", Status: 1, CreateTime: ts, UpdateTime: ts})
	if err == nil {
		t.Fatal("second Insert want error")
	}
	var me *mysql.MySQLError
	if !errors.As(err, &me) || me.Number != 1062 {
		t.Fatalf("want duplicate key 1062, got %v", err)
	}
}

// TC-0319: 记录不存在
func TestSysProductMemberModel_FindOne_NotFound(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	_, err := m.FindOne(context.Background(), 999999999999)
	if err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0392: FindOneByProductCodeUserId
func TestSysProductMemberModel_FindOneByProductCodeUserId_NotFound(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	_, err := m.FindOneByProductCodeUserId(context.Background(), "notexist_"+testutil.UniqueId(), 999999999)
	if err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0476: 空结果
func TestSysProductMemberModel_FindListByProductCode_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	list, total, err := m.FindListByProductCode(context.Background(), "empty_"+testutil.UniqueId(), 1, 10)
	if err != nil {
		t.Fatalf("err: %v", err)
	}
	if total != 0 || len(list) != 0 {
		t.Fatalf("want empty got total=%d len=%d", total, len(list))
	}
}

// TC-0334: 空列表
func TestSysProductMemberModel_BatchInsert_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	if err := m.BatchInsert(context.Background(), nil); err != nil {
		t.Fatalf("nil: %v", err)
	}
	if err := m.BatchInsert(context.Background(), []*SysProductMember{}); err != nil {
		t.Fatalf("empty: %v", err)
	}
}

// TC-0353: 空ids
func TestSysProductMemberModel_BatchDelete_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	if err := m.BatchDelete(context.Background(), nil); err != nil {
		t.Fatalf("nil: %v", err)
	}
	if err := m.BatchDelete(context.Background(), []int64{}); err != nil {
		t.Fatalf("empty: %v", err)
	}
}

// TC-0314: 事务内插入
func TestSysProductMemberModel_InsertWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_itx_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	var insertedId int64
	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		res, err := m.InsertWithTx(c, session, &SysProductMember{
			ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
		})
		if err != nil {
			return err
		}
		insertedId, _ = res.LastInsertId()
		return nil
	})
	if err != nil {
		t.Fatalf("TransactCtx: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_product_member", insertedId)

	got, err := m.FindOne(ctx, insertedId)
	if err != nil {
		t.Fatalf("FindOne: %v", err)
	}
	if got.ProductCode != pc || got.UserId != userId {
		t.Fatalf("mismatch: %+v", got)
	}
}

// TC-0316: 事务回滚后无数据
func TestSysProductMemberModel_InsertWithTx_Rollback(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_irb_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		_, err := m.InsertWithTx(c, session, &SysProductMember{
			ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
		})
		if err != nil {
			return err
		}
		return errors.New("rollback")
	})
	if err == nil || err.Error() != "rollback" {
		t.Fatalf("want rollback error got %v", err)
	}
	_, err = m.FindOneByProductCodeUserId(ctx, pc, userId)
	if err != ErrNotFound {
		t.Fatalf("after rollback want ErrNotFound got %v", err)
	}
}

// TC-0326: 记录不存在
func TestSysProductMemberModel_Update_NotFound(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	ts := time.Now().Unix()
	err := m.Update(context.Background(), &SysProductMember{
		Id: 999999999, ProductCode: "nope", UserId: 1, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
	})
	if err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0327: 事务内更新
func TestSysProductMemberModel_UpdateWithTx(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_utx_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysProductMember{
		ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
	})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_product_member", id)

	newTs := ts + 100
	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.UpdateWithTx(c, session, &SysProductMember{
			Id: id, ProductCode: pc, UserId: userId, MemberType: "ADMIN", Status: 2, CreateTime: ts, UpdateTime: newTs,
		})
	})
	if err != nil {
		t.Fatalf("UpdateWithTx: %v", err)
	}
	got, err := m.FindOne(ctx, id)
	if err != nil {
		t.Fatalf("FindOne: %v", err)
	}
	if got.MemberType != "ADMIN" || got.Status != 2 || got.UpdateTime != newTs {
		t.Fatalf("mismatch: %+v", got)
	}
}

// TC-0329: 记录不存在
func TestSysProductMemberModel_Delete_NotFound(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	err := m.Delete(context.Background(), 999999999)
	if err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0330: 事务内删除
func TestSysProductMemberModel_DeleteWithTx(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_dtx_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysProductMember{
		ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
	})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_product_member", id)

	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.DeleteWithTx(c, session, id)
	})
	if err != nil {
		t.Fatalf("DeleteWithTx: %v", err)
	}
	if _, err := m.FindOne(ctx, id); err != ErrNotFound {
		t.Fatalf("after DeleteWithTx want ErrNotFound got %v", err)
	}
}

// TC-0331: 正常事务
func TestSysProductMemberModel_TransactCtx_CommitAndRollback(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_txc_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	var insertedId int64
	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		res, err := m.InsertWithTx(c, session, &SysProductMember{
			ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
		})
		if err != nil {
			return err
		}
		insertedId, _ = res.LastInsertId()
		return nil
	})
	if err != nil {
		t.Fatalf("commit: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_product_member", insertedId)

	got, err := m.FindOne(ctx, insertedId)
	if err != nil {
		t.Fatalf("FindOne after commit: %v", err)
	}
	if got.ProductCode != pc {
		t.Fatalf("productCode mismatch: %s", got.ProductCode)
	}

	pc2 := "t_pm_txr_" + testutil.UniqueId()
	userId2 := randProductMemberUserId()
	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		_, err := m.InsertWithTx(c, session, &SysProductMember{
			ProductCode: pc2, UserId: userId2, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
		})
		if err != nil {
			return err
		}
		return errors.New("rollback")
	})
	if err == nil || err.Error() != "rollback" {
		t.Fatalf("want rollback error got %v", err)
	}
	_, err = m.FindOneByProductCodeUserId(ctx, pc2, userId2)
	if err != ErrNotFound {
		t.Fatalf("after rollback want ErrNotFound got %v", err)
	}
}

// TC-0333: 获取表名
func TestSysProductMemberModel_TableName(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	if m.TableName() != "`sys_product_member`" {
		t.Fatalf("want `sys_product_member` got %s", m.TableName())
	}
}

// TC-0335: 单条记录
func TestSysProductMemberModel_BatchInsert_Single(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_bis_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	if err := m.BatchInsert(ctx, []*SysProductMember{
		{ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts},
	}); err != nil {
		t.Fatalf("BatchInsert: %v", err)
	}
	got, err := m.FindOneByProductCodeUserId(ctx, pc, userId)
	if err != nil {
		t.Fatalf("FindOneByProductCodeUserId: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_product_member", got.Id)
	if got.MemberType != "MEMBER" {
		t.Fatalf("mismatch: %+v", got)
	}
}

// TC-0338: 唯一索引冲突
func TestSysProductMemberModel_BatchInsert_UniqueConflict(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_bic_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	err := m.BatchInsert(ctx, []*SysProductMember{
		{ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts},
		{ProductCode: pc, UserId: userId, MemberType: "ADMIN", Status: 1, CreateTime: ts, UpdateTime: ts},
	})
	if err == nil {
		t.Fatal("want error for duplicate")
	}
	var me *mysql.MySQLError
	if !errors.As(err, &me) || me.Number != 1062 {
		t.Fatalf("want duplicate key 1062, got %v", err)
	}
}

// TC-0343: 空列表
func TestSysProductMemberModel_BatchUpdate_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	if err := m.BatchUpdate(context.Background(), nil); err != nil {
		t.Fatalf("nil: %v", err)
	}
	if err := m.BatchUpdate(context.Background(), []*SysProductMember{}); err != nil {
		t.Fatalf("empty: %v", err)
	}
}

// TC-0345: 多条记录(3条)
func TestSysProductMemberModel_BatchUpdate_Multi(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_bum_" + testutil.UniqueId()
	u1, u2 := randProductMemberUserId(), randProductMemberUserId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysProductMember{ProductCode: pc, UserId: u1, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert1: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysProductMember{ProductCode: pc, UserId: u2, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert2: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_product_member", id1, id2)

	newTs := ts + 100
	err = m.BatchUpdate(ctx, []*SysProductMember{
		{Id: id1, ProductCode: pc, UserId: u1, MemberType: "ADMIN", Status: 2, CreateTime: ts, UpdateTime: newTs},
		{Id: id2, ProductCode: pc, UserId: u2, MemberType: "ADMIN", Status: 2, CreateTime: ts, UpdateTime: newTs},
	})
	if err != nil {
		t.Fatalf("BatchUpdate: %v", err)
	}
	got1, err := m.FindOne(ctx, id1)
	if err != nil {
		t.Fatalf("FindOne1: %v", err)
	}
	if got1.MemberType != "ADMIN" || got1.Status != 2 || got1.UpdateTime != newTs {
		t.Fatalf("got1 mismatch: %+v", got1)
	}
	got2, err := m.FindOne(ctx, id2)
	if err != nil {
		t.Fatalf("FindOne2: %v", err)
	}
	if got2.MemberType != "ADMIN" || got2.Status != 2 || got2.UpdateTime != newTs {
		t.Fatalf("got2 mismatch: %+v", got2)
	}
}

// TC-0355: 多个id(3个)
func TestSysProductMemberModel_BatchDelete_Multi(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_bdm_" + testutil.UniqueId()
	ts := time.Now().Unix()
	var ids []int64
	for i := 0; i < 3; i++ {
		res, err := m.Insert(ctx, &SysProductMember{
			ProductCode: pc, UserId: randProductMemberUserId(), MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
		})
		if err != nil {
			t.Fatalf("Insert: %v", err)
		}
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	defer func() {
		for _, id := range ids {
			testutil.CleanTable(ctx, conn, "sys_product_member", id)
		}
	}()

	if err := m.BatchDelete(ctx, ids); err != nil {
		t.Fatalf("BatchDelete: %v", err)
	}
	for _, id := range ids {
		if _, err := m.FindOne(ctx, id); err != ErrNotFound {
			t.Fatalf("id %d should be deleted: %v", id, err)
		}
	}
}

// TC-0354: 单个id
func TestSysProductMemberModel_BatchDelete_Single(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_bds_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysProductMember{
		ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
	})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_product_member", id)

	if err := m.BatchDelete(ctx, []int64{id}); err != nil {
		t.Fatalf("BatchDelete: %v", err)
	}
	if _, err := m.FindOne(ctx, id); err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0356: 包含不存在id
func TestSysProductMemberModel_BatchDelete_ContainsNonExist(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_bdn_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysProductMember{
		ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
	})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_product_member", id)

	if err := m.BatchDelete(ctx, []int64{id, 999999999}); err != nil {
		t.Fatalf("BatchDelete: %v", err)
	}
	if _, err := m.FindOne(ctx, id); err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0341: 正常多条
func TestSysProductMemberModel_BatchInsertWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_bitn_" + testutil.UniqueId()
	u1, u2 := randProductMemberUserId(), randProductMemberUserId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.BatchInsertWithTx(c, session, []*SysProductMember{
			{ProductCode: pc, UserId: u1, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts},
			{ProductCode: pc, UserId: u2, MemberType: "ADMIN", Status: 1, CreateTime: ts, UpdateTime: ts},
		})
	})
	if err != nil {
		t.Fatalf("BatchInsertWithTx: %v", err)
	}
	got1, err := m.FindOneByProductCodeUserId(ctx, pc, u1)
	if err != nil {
		t.Fatalf("FindOne u1: %v", err)
	}
	got2, err := m.FindOneByProductCodeUserId(ctx, pc, u2)
	if err != nil {
		t.Fatalf("FindOne u2: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_product_member", got1.Id, got2.Id)
}

// TC-0340: 空列表
func TestSysProductMemberModel_BatchInsertWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.BatchInsertWithTx(c, session, nil); err != nil {
			return err
		}
		return m.BatchInsertWithTx(c, session, []*SysProductMember{})
	})
	if err != nil {
		t.Fatalf("BatchInsertWithTx empty: %v", err)
	}
}

// TC-0342: 事务回滚
func TestSysProductMemberModel_BatchInsertWithTx_Rollback(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_bitr_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.BatchInsertWithTx(c, session, []*SysProductMember{
			{ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts},
		}); err != nil {
			return err
		}
		return errors.New("rollback")
	})
	if err == nil || err.Error() != "rollback" {
		t.Fatalf("want rollback error got %v", err)
	}
	_, err = m.FindOneByProductCodeUserId(ctx, pc, userId)
	if err != ErrNotFound {
		t.Fatalf("after rollback want ErrNotFound got %v", err)
	}
}

// TC-0349: 正常多条
func TestSysProductMemberModel_BatchUpdateWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_butn_" + testutil.UniqueId()
	u1, u2 := randProductMemberUserId(), randProductMemberUserId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysProductMember{ProductCode: pc, UserId: u1, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert1: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysProductMember{ProductCode: pc, UserId: u2, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert2: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_product_member", id1, id2)

	newTs := ts + 200
	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.BatchUpdateWithTx(c, session, []*SysProductMember{
			{Id: id1, ProductCode: pc, UserId: u1, MemberType: "ADMIN", Status: 2, CreateTime: ts, UpdateTime: newTs},
			{Id: id2, ProductCode: pc, UserId: u2, MemberType: "ADMIN", Status: 2, CreateTime: ts, UpdateTime: newTs},
		})
	})
	if err != nil {
		t.Fatalf("BatchUpdateWithTx: %v", err)
	}
	got1, err := m.FindOne(ctx, id1)
	if err != nil {
		t.Fatalf("FindOne1: %v", err)
	}
	if got1.MemberType != "ADMIN" || got1.Status != 2 || got1.UpdateTime != newTs {
		t.Fatalf("got1 mismatch: %+v", got1)
	}
}

// TC-0348: 空列表
func TestSysProductMemberModel_BatchUpdateWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.BatchUpdateWithTx(c, session, nil); err != nil {
			return err
		}
		return m.BatchUpdateWithTx(c, session, []*SysProductMember{})
	})
	if err != nil {
		t.Fatalf("BatchUpdateWithTx empty: %v", err)
	}
}

// TC-0358: 正常多条
func TestSysProductMemberModel_BatchDeleteWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_bdtn_" + testutil.UniqueId()
	ts := time.Now().Unix()
	var ids []int64
	for i := 0; i < 2; i++ {
		res, err := m.Insert(ctx, &SysProductMember{
			ProductCode: pc, UserId: randProductMemberUserId(), MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
		})
		if err != nil {
			t.Fatalf("Insert: %v", err)
		}
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	defer func() {
		for _, id := range ids {
			testutil.CleanTable(ctx, conn, "sys_product_member", id)
		}
	}()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.BatchDeleteWithTx(c, session, ids)
	})
	if err != nil {
		t.Fatalf("BatchDeleteWithTx: %v", err)
	}
	for _, id := range ids {
		if _, err := m.FindOne(ctx, id); err != ErrNotFound {
			t.Fatalf("id %d should be deleted: %v", id, err)
		}
	}
}

// TC-0357: 空ids
func TestSysProductMemberModel_BatchDeleteWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.BatchDeleteWithTx(c, session, nil); err != nil {
			return err
		}
		return m.BatchDeleteWithTx(c, session, []int64{})
	})
	if err != nil {
		t.Fatalf("BatchDeleteWithTx empty: %v", err)
	}
}

// TC-0323: 事务内可见性
func TestSysProductMemberModel_FindOneWithTx_InsertThenFind(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_fotx_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	var insertedId int64
	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		res, err := m.InsertWithTx(c, session, &SysProductMember{
			ProductCode: pc, UserId: userId, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
		})
		if err != nil {
			return err
		}
		insertedId, err = res.LastInsertId()
		if err != nil {
			return err
		}
		got, err := m.FindOneWithTx(c, session, insertedId)
		if err != nil {
			return err
		}
		assert.Equal(t, pc, got.ProductCode)
		assert.Equal(t, userId, got.UserId)
		assert.Equal(t, "MEMBER", got.MemberType)
		return nil
	})
	require.NoError(t, err)
	defer testutil.CleanTable(ctx, conn, "sys_product_member", insertedId)
}

// TC-0322: 事务内记录不存在
func TestSysProductMemberModel_FindOneWithTx_NotFound(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		_, err := m.FindOneWithTx(c, session, 999999999999)
		require.ErrorIs(t, err, ErrNotFound)
		return nil
	})
	require.NoError(t, err)
}

// TC-0393: FindOneByProductCodeUserIdWithTx
func TestSysProductMemberModel_FindOneByProductCodeUserIdWithTx_InsertThenFind(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_fbytx_" + testutil.UniqueId()
	userId := randProductMemberUserId()
	ts := time.Now().Unix()

	var insertedId int64
	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		res, err := m.InsertWithTx(c, session, &SysProductMember{
			ProductCode: pc, UserId: userId, MemberType: "ADMIN", Status: 1, CreateTime: ts, UpdateTime: ts,
		})
		if err != nil {
			return err
		}
		insertedId, err = res.LastInsertId()
		if err != nil {
			return err
		}
		got, err := m.FindOneByProductCodeUserIdWithTx(c, session, pc, userId)
		if err != nil {
			return err
		}
		assert.Equal(t, insertedId, got.Id)
		assert.Equal(t, pc, got.ProductCode)
		assert.Equal(t, userId, got.UserId)
		return nil
	})
	require.NoError(t, err)
	defer testutil.CleanTable(ctx, conn, "sys_product_member", insertedId)
}

// TC-0394: FindOneByProductCodeUserIdWithTx
func TestSysProductMemberModel_FindOneByProductCodeUserIdWithTx_NotFound(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		_, err := m.FindOneByProductCodeUserIdWithTx(c, session, "notexist_"+testutil.UniqueId(), 999999999)
		require.ErrorIs(t, err, ErrNotFound)
		return nil
	})
	require.NoError(t, err)
}

// TC-0478: FindMapByProductCodeUserIds - 空userIds
func TestSysProductMemberModel_FindMapByProductCodeUserIds_EmptyUserIds(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_empty_" + testutil.UniqueId()

	m1, err := m.FindMapByProductCodeUserIds(context.Background(), pc, nil)
	require.NoError(t, err)
	assert.Empty(t, m1)

	m2, err := m.FindMapByProductCodeUserIds(context.Background(), pc, []int64{})
	require.NoError(t, err)
	assert.Empty(t, m2)
}

// TC-0480: FindMapByProductCodeUserIds - map key正确
func TestSysProductMemberModel_FindMapByProductCodeUserIds_MapKeysCorrect(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_key_" + testutil.UniqueId()
	u1, u2 := randProductMemberUserId(), randProductMemberUserId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysProductMember{
		ProductCode: pc, UserId: u1, MemberType: "MEMBER", Status: 1, CreateTime: ts, UpdateTime: ts,
	})
	require.NoError(t, err)
	id1, _ := res1.LastInsertId()

	res2, err := m.Insert(ctx, &SysProductMember{
		ProductCode: pc, UserId: u2, MemberType: "ADMIN", Status: 1, CreateTime: ts, UpdateTime: ts,
	})
	require.NoError(t, err)
	id2, _ := res2.LastInsertId()
	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "sys_product_member", id1, id2) })

	result, err := m.FindMapByProductCodeUserIds(ctx, pc, []int64{u1, u2})
	require.NoError(t, err)
	require.Len(t, result, 2)

	v1, ok1 := result[u1]
	require.True(t, ok1, "map should contain key userId=%d", u1)
	assert.Equal(t, id1, v1.Id)
	assert.Equal(t, pc, v1.ProductCode)
	assert.Equal(t, u1, v1.UserId)
	assert.Equal(t, "MEMBER", v1.MemberType)

	v2, ok2 := result[u2]
	require.True(t, ok2, "map should contain key userId=%d", u2)
	assert.Equal(t, id2, v2.Id)
	assert.Equal(t, pc, v2.ProductCode)
	assert.Equal(t, u2, v2.UserId)
	assert.Equal(t, "ADMIN", v2.MemberType)
}