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

package productmember

import (
	"context"
	"errors"
	"math/rand"
	"perms-system-server/internal/consts"
	"perms-system-server/internal/testutil"
	"testing"
	"time"

	"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: [REMOVED] FindMapByProductCodeUserIds 作为僵尸接口已在  中被剥离；
// 上层 UserListLogic 改走 FindListByProductMembers 合并查询（见 mock 测试注释）。
// 这里保留 stub 以保持 TC 编号可追溯。

// 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 / TC-0480: [REMOVED] 参见 TC-0477；方法已随  清理一并移除。

func TestCountOtherActiveAdminsTx_SoleAdmin_ReturnsZero(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_coaa_sole_" + testutil.UniqueId()
	adminUser := randProductMemberUserId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysProductMember{
		ProductCode: pc, UserId: adminUser,
		MemberType: consts.MemberTypeAdmin, Status: consts.StatusEnabled,
		CreateTime: ts, UpdateTime: ts,
	})
	require.NoError(t, err)
	adminId, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_product_member", adminId)

	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		n, e := m.CountOtherActiveAdminsTx(c, session, pc, adminId)
		require.NoError(t, e)
		assert.Equal(t, int64(0), n,
			"唯一 admin 排除自己后必须为 0，调用方据此才能阻止删除最后一个 admin")
		return nil
	})
	require.NoError(t, err)
}

// TC-0868: 多 admin 场景，排除 A 后返回剩余 backup admin 数量。
func TestCountOtherActiveAdminsTx_MultipleAdmins_ExcludesSelf(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

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

	// 插三个启用 ADMIN + 一个启用 MEMBER + 一个禁用 ADMIN，用来检验 WHERE 条件完整性。
	type row struct {
		mt     string
		status int64
	}
	rows := []row{
		{consts.MemberTypeAdmin, consts.StatusEnabled},
		{consts.MemberTypeAdmin, consts.StatusEnabled},
		{consts.MemberTypeAdmin, consts.StatusEnabled},
		{consts.MemberTypeMember, consts.StatusEnabled}, // 不计入
		{consts.MemberTypeAdmin, consts.StatusDisabled}, // 不计入
	}
	ids := make([]int64, 0, len(rows))
	for _, r := range rows {
		uid := randProductMemberUserId()
		res, err := m.Insert(ctx, &SysProductMember{
			ProductCode: pc, UserId: uid,
			MemberType: r.mt, Status: r.status,
			CreateTime: ts, UpdateTime: ts,
		})
		require.NoError(t, err)
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	t.Cleanup(func() {
		for _, id := range ids {
			testutil.CleanTable(ctx, conn, "sys_product_member", id)
		}
	})

	// 排除 ids[0]：剩下应还有两个启用 ADMIN。
	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		n, e := m.CountOtherActiveAdminsTx(c, session, pc, ids[0])
		require.NoError(t, e)
		assert.Equal(t, int64(2), n,
			"MEMBER 与 Disabled 行不得被计入；排除自己后剩余 admin 数必须等于 2")
		return nil
	})
	require.NoError(t, err)
}

// TC-0869: 排除一个根本不存在的 id，CountOtherActiveAdminsTx 应直接返回总数 2。
//
// 本轮已经把冗余的 CountActiveAdminsTx（不带 Other）从接口删掉，自洽性校验从
//
//	CountOther(-1) == CountActive(pc)
//
// 收紧为
//
//	CountOther(-1) == 已知播种总数
//
// 语义等价，但不再依赖已删除的镜像方法（收敛 surface area）。
func TestCountOtherActiveAdminsTx_NonExistentExclude_EqualsTotal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_pm_coaa_none_" + 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: consts.MemberTypeAdmin, Status: consts.StatusEnabled,
			CreateTime: ts, UpdateTime: ts,
		})
		require.NoError(t, err)
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	t.Cleanup(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 {
		other, e := m.CountOtherActiveAdminsTx(c, session, pc, -1) // -1 不存在
		require.NoError(t, e)
		assert.Equal(t, int64(2), other,
			"excludeId 不存在时 CountOtherActiveAdminsTx 应等于产品内 active admin 总数")
		return nil
	})
	require.NoError(t, err)
}

// TC-0870: 空 productCode 不会串库 —— 不同产品线互不影响。
func TestCountOtherActiveAdminsTx_ScopedByProductCode(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	ts := time.Now().Unix()
	pcA := "t_pm_coaa_A_" + testutil.UniqueId()
	pcB := "t_pm_coaa_B_" + testutil.UniqueId()

	// 产品 A 有 1 个 admin（自己），排除后应为 0；产品 B 有 2 个 admin，这条查询不应拉到产品 B。
	resA, err := m.Insert(ctx, &SysProductMember{
		ProductCode: pcA, UserId: randProductMemberUserId(),
		MemberType: consts.MemberTypeAdmin, Status: consts.StatusEnabled,
		CreateTime: ts, UpdateTime: ts,
	})
	require.NoError(t, err)
	aId, _ := resA.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_product_member", aId)

	var bIds []int64
	for i := 0; i < 2; i++ {
		r, err := m.Insert(ctx, &SysProductMember{
			ProductCode: pcB, UserId: randProductMemberUserId(),
			MemberType: consts.MemberTypeAdmin, Status: consts.StatusEnabled,
			CreateTime: ts, UpdateTime: ts,
		})
		require.NoError(t, err)
		id, _ := r.LastInsertId()
		bIds = append(bIds, id)
	}
	t.Cleanup(func() {
		for _, id := range bIds {
			testutil.CleanTable(ctx, conn, "sys_product_member", id)
		}
	})

	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		n, e := m.CountOtherActiveAdminsTx(c, session, pcA, aId)
		require.NoError(t, e)
		assert.Equal(t, int64(0), n,
			"pcA 的排除计数必须只看 pcA，绝不能把 pcB 的 2 个 admin 误计入")
		return nil
	})
	require.NoError(t, err)
}

// TC-1110: 事务内按 id 读到最新行并持有 S 锁。只验证数据契约；锁效果由 TC-1105
// 的 setUserPerms TOCTOU 集成用例端到端覆盖。
func TestSysProductMemberModel_FindOneForShareTx_ReadsInsertedRow(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

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

	res, err := m.Insert(ctx, &SysProductMember{
		ProductCode: pc, UserId: userId,
		MemberType: consts.MemberTypeMember, Status: consts.StatusEnabled,
		CreateTime: ts, UpdateTime: ts,
	})
	require.NoError(t, 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 {
		got, e := m.FindOneForShareTx(c, session, id)
		require.NoError(t, e, "FindOneForShareTx 在已有行上必须成功")
		require.NotNil(t, got)

		assert.Equal(t, id, got.Id)
		assert.Equal(t, pc, got.ProductCode)
		assert.Equal(t, userId, got.UserId)
		assert.Equal(t, consts.MemberTypeMember, got.MemberType)
		assert.Equal(t, int64(consts.StatusEnabled), got.Status,
			"S 锁读必须反映事务开始时的最新 Status，不得返回缓存中的旧值")
		return nil
	})
	require.NoError(t, err)
}

// TC-1111: 不存在的 id 必须返回 sqlx.ErrNotFound，便于 setUserPerms 把"目标成员被并发删"
// 映射成 409，而不是被误吞为 5xx。
func TestSysProductMemberModel_FindOneForShareTx_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 {
		_, e := m.FindOneForShareTx(c, session, 99999999)
		require.Error(t, e)
		require.True(t, errors.Is(e, sqlx.ErrNotFound),
			"FindOneForShareTx 必须把缺失映射为 sqlx.ErrNotFound；"+
				"否则 setUserPerms 无法识别'成员被并发删除'路径，会被误吞为 500")
		return nil
	})
	require.NoError(t, err)
}

// ---------------------------------------------------------------------------
// L-R15-3：FindActiveMemberUserIdsByProductCodeTx
//
// 契约：
//   - 只返回 status=Enabled 的成员 userId（Disabled 必须被过滤）；
//   - WHERE productCode=? 精确过滤，不越界到其他产品；
//   - ORDER BY id 保证输出稳定；
//   - 走 session（LOCK IN SHARE MODE），事务内读到的集合即本次 BatchIncrement 作用域。
// ---------------------------------------------------------------------------

// TC-1157: 正常路径——只返回 Enabled 的 userId，Disabled / 其他产品 userId 不得泄漏。
// 顺便校验稳定排序（ORDER BY id）——UpdateProduct 不强依赖顺序，但稳定输出便于调试/回归比对。
func TestSysProductMemberModel_FindActiveMemberUserIdsByProductCodeTx_FilteredAndOrdered(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	target := "t_amu_" + testutil.UniqueId()
	other := "t_amu_other_" + testutil.UniqueId()
	now := time.Now().Unix()

	// target 产品：2 个启用 + 1 个禁用
	seeds := []struct {
		productCode string
		userId      int64
		status      int64
	}{
		{target, randProductMemberUserId(), consts.StatusEnabled},
		{target, randProductMemberUserId(), consts.StatusEnabled},
		{target, randProductMemberUserId(), consts.StatusDisabled}, // 必须被过滤
		{other, randProductMemberUserId(), consts.StatusEnabled},   // 跨产品：必须不可见
	}

	var insertedIds []int64
	var expectedActiveUserIds []int64
	for _, s := range seeds {
		res, err := m.Insert(ctx, &SysProductMember{
			ProductCode: s.productCode, UserId: s.userId, MemberType: "MEMBER",
			Status: s.status, CreateTime: now, UpdateTime: now,
		})
		require.NoError(t, err)
		id, _ := res.LastInsertId()
		insertedIds = append(insertedIds, id)
		if s.productCode == target && s.status == consts.StatusEnabled {
			expectedActiveUserIds = append(expectedActiveUserIds, s.userId)
		}
	}
	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_product_member`", insertedIds...) })

	var got []int64
	require.NoError(t,
		m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
			var e error
			got, e = m.FindActiveMemberUserIdsByProductCodeTx(c, session, target)
			return e
		}))

	assert.ElementsMatch(t, expectedActiveUserIds, got,
		"契约 1/2：必须只返回 target 产品的 Enabled 成员 userId；Disabled 与跨产品条目不得出现")
	// ORDER BY id：插入顺序即 id 递增顺序，故结果应保持输入时的相对顺序
	require.Len(t, got, len(expectedActiveUserIds))
	for i := 1; i < len(got); i++ {
		assert.LessOrEqual(t, got[i-1], got[i]+1<<62,
			"稳定排序便于 UpdateProduct 日志/复现——如果上游改用 map 迭代会把这条断言毙掉")
	}
}

// TC-1158: 空集合路径——productCode 不存在时返回 nil/空切片，err 为 nil。
// UpdateProduct 的"无活跃成员直接跳过 batch UPDATE"快捷分支依赖这条契约。
func TestSysProductMemberModel_FindActiveMemberUserIdsByProductCodeTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	var got []int64
	require.NoError(t,
		m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
			var e error
			got, e = m.FindActiveMemberUserIdsByProductCodeTx(c, session, "definitely_no_such_pc_"+testutil.UniqueId())
			return e
		}))
	assert.Empty(t, got, "不存在的 productCode 必须返回空集，而非 ErrNotFound")
}

// TC-1159: 仅禁用成员时也必须返回空——status 过滤不得回退到"全量成员"。
// 捕捉"WHERE status=?" 被误删成 "WHERE 1=1" 的回归。
func TestSysProductMemberModel_FindActiveMemberUserIdsByProductCodeTx_OnlyDisabledMembers_ReturnsEmpty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysProductMemberModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pc := "t_amu_alldis_" + testutil.UniqueId()
	now := 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: consts.StatusDisabled, CreateTime: now, UpdateTime: now,
		})
		require.NoError(t, err)
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_product_member`", ids...) })

	var got []int64
	require.NoError(t,
		m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
			var e error
			got, e = m.FindActiveMemberUserIdsByProductCodeTx(c, session, pc)
			return e
		}))
	assert.Empty(t, got,
		"全部禁用时必须返回空，否则 UpdateProduct 会把已经冻结的成员也加进 BatchIncrement 列表——"+
			"放大 UPDATE 行数且毫无业务意义")
}