perms-system-server/internal/model/userrole/sysUserRoleModel_test.go

package userrole

import (
	"context"
	"errors"
	"math/rand"
	"sort"
	"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 randUserRoleId() int64 {
	return int64(900000 + rand.Intn(100000))
}

func sortedInt64Copy(a []int64) []int64 {
	b := append([]int64(nil), a...)
	sort.Slice(b, func(i, j int) bool { return b[i] < b[j] })
	return b
}

func int64SliceEqualIgnoreOrder(a, b []int64) bool {
	if len(a) != len(b) {
		return false
	}
	aa, bb := sortedInt64Copy(a), sortedInt64Copy(b)
	for i := range aa {
		if aa[i] != bb[i] {
			return false
		}
	}
	return true
}

func insertTestRole(t *testing.T, ctx context.Context, conn sqlx.SqlConn, productCode, name string) int64 {
	t.Helper()
	ts := time.Now().Unix()
	q := "INSERT INTO `sys_role` (`productCode`, `name`, `remark`, `status`, `permsLevel`, `createTime`, `updateTime`) VALUES (?, ?, '', 1, 0, ?, ?)"
	res, err := conn.ExecCtx(ctx, q, productCode, name, ts, ts)
	if err != nil {
		t.Fatalf("insert sys_role: %v", err)
	}
	id, err := res.LastInsertId()
	if err != nil {
		t.Fatalf("role LastInsertId: %v", err)
	}
	return id
}

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

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	data := &SysUserRole{
		UserId:     userId,
		RoleId:     roleId,
		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_user_role", id)

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

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

	newTs := ts + 1
	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.UpdateTime != newTs {
		t.Fatalf("UpdateTime want %d got %d", newTs, updated.UpdateTime)
	}

	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-0467: 正常查询
func TestSysUserRoleModel_FindRoleIdsByUserId(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	r1, r2 := randUserRoleId(), randUserRoleId()
	ts := time.Now().Unix()

	var ids []int64
	for _, roleId := range []int64{r1, r2} {
		res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, 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_user_role", id)
		}
	}()

	got, err := m.FindRoleIdsByUserId(ctx, userId)
	if err != nil {
		t.Fatalf("FindRoleIdsByUserId: %v", err)
	}
	if !int64SliceEqualIgnoreOrder(got, []int64{r1, r2}) {
		t.Fatalf("got %v want %v", got, []int64{r1, r2})
	}
}

// TC-0444: 正常查询
// TC-0469: 正常删除
func TestSysUserRoleModel_DeleteByRoleIdTx(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", id)

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

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

// TC-0388: FindOneByUserIdRoleId
func TestSysUserRoleModel_FindOneByUserIdRoleId_NotFound(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	_, err := m.FindOneByUserIdRoleId(context.Background(), 999999999, 999999999)
	if err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0468: 无绑定
func TestSysUserRoleModel_FindRoleIdsByUserId_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	got, err := m.FindRoleIdsByUserId(context.Background(), 999999999)
	if err != nil {
		t.Fatalf("err: %v", err)
	}
	if len(got) != 0 {
		t.Fatalf("want empty got %v", got)
	}
}

// TC-0470: 事务内跨产品删除
func TestSysUserRoleModel_DeleteByUserIdForProductTx(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pcA := "t_urt_a_" + testutil.UniqueId()
	pcB := "t_urt_b_" + testutil.UniqueId()
	nameA := "n_ta_" + testutil.UniqueId()
	nameB := "n_tb_" + testutil.UniqueId()

	roleA := insertTestRole(t, ctx, conn, pcA, nameA)
	roleB := insertTestRole(t, ctx, conn, pcB, nameB)
	defer testutil.CleanTable(ctx, conn, "sys_role", roleA, roleB)

	userId := randUserRoleId()
	ts := time.Now().Unix()

	resA, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleA, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert A: %v", err)
	}
	idA, _ := resA.LastInsertId()
	resB, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleB, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert B: %v", err)
	}
	idB, _ := resB.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", idA, idB)

	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.DeleteByUserIdForProductTx(c, session, userId, pcA)
	})
	if err != nil {
		t.Fatalf("DeleteByUserIdForProductTx: %v", err)
	}
	if _, err := m.FindOne(ctx, idA); err != ErrNotFound {
		t.Fatalf("pcA row should delete: %v", err)
	}
	if _, err := m.FindOne(ctx, idB); err != nil {
		t.Fatalf("pcB row should remain: %v", err)
	}
}

// TC-0334: 空列表
func TestSysUserRoleModel_BatchInsert_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(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(), []*SysUserRole{}); err != nil {
		t.Fatalf("empty: %v", err)
	}
}

// TC-0353: 空ids
func TestSysUserRoleModel_BatchDelete_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(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-0312: 唯一索引冲突
func TestSysUserRoleModel_Insert_UniqueConflict(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", id)

	_, err = m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, 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-0314: 事务内插入
func TestSysUserRoleModel_InsertWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	roleId := randUserRoleId()
	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, &SysUserRole{UserId: userId, RoleId: roleId, 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_user_role", insertedId)

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

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

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		_, err := m.InsertWithTx(c, session, &SysUserRole{UserId: userId, RoleId: roleId, 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.FindOneByUserIdRoleId(ctx, userId, roleId)
	if err != ErrNotFound {
		t.Fatalf("after rollback want ErrNotFound got %v", err)
	}
}

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

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

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

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", id)

	newTs := ts + 100
	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.UpdateWithTx(c, session, &SysUserRole{
			Id: id, UserId: userId, RoleId: roleId, 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.UpdateTime != newTs {
		t.Fatalf("UpdateTime want %d got %d", newTs, got.UpdateTime)
	}
}

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

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

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", 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-0332: fn返回错误
func TestSysUserRoleModel_TransactCtx_Rollback(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", id)

	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.DeleteWithTx(c, session, id); err != nil {
			return err
		}
		return errors.New("rollback")
	})
	if err == nil || err.Error() != "rollback" {
		t.Fatalf("want rollback error got %v", err)
	}
	got, err := m.FindOne(ctx, id)
	if err != nil {
		t.Fatalf("after rollback FindOne: %v", err)
	}
	if got.Id != id {
		t.Fatalf("row should still exist")
	}
}

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

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

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	if err := m.BatchInsert(ctx, []*SysUserRole{
		{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts},
	}); err != nil {
		t.Fatalf("BatchInsert: %v", err)
	}
	got, err := m.FindOneByUserIdRoleId(ctx, userId, roleId)
	if err != nil {
		t.Fatalf("FindOneByUserIdRoleId: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_user_role", got.Id)
	if got.UserId != userId || got.RoleId != roleId {
		t.Fatalf("mismatch: %+v", got)
	}
}

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

	u1 := randUserRoleId()
	r1, r2, r3 := randUserRoleId(), randUserRoleId(), randUserRoleId()
	ts := time.Now().Unix()

	if err := m.BatchInsert(ctx, []*SysUserRole{
		{UserId: u1, RoleId: r1, CreateTime: ts, UpdateTime: ts},
		{UserId: u1, RoleId: r2, CreateTime: ts, UpdateTime: ts},
		{UserId: u1, RoleId: r3, CreateTime: ts, UpdateTime: ts},
	}); err != nil {
		t.Fatalf("BatchInsert: %v", err)
	}
	var ids []int64
	for _, roleId := range []int64{r1, r2, r3} {
		got, err := m.FindOneByUserIdRoleId(ctx, u1, roleId)
		if err != nil {
			t.Fatalf("FindOneByUserIdRoleId(%d,%d): %v", u1, roleId, err)
		}
		ids = append(ids, got.Id)
	}
	defer func() {
		for _, id := range ids {
			testutil.CleanTable(ctx, conn, "sys_user_role", id)
		}
	}()
	if len(ids) != 3 {
		t.Fatalf("want 3 rows got %d", len(ids))
	}
}

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

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	err := m.BatchInsert(ctx, []*SysUserRole{
		{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts},
		{UserId: userId, RoleId: roleId, 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 TestSysUserRoleModel_BatchUpdate_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(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(), []*SysUserRole{}); err != nil {
		t.Fatalf("empty: %v", err)
	}
}

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

	userId := randUserRoleId()
	r1, r2 := randUserRoleId(), randUserRoleId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: r1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert1: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: r2, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert2: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", id1, id2)

	newTs := ts + 100
	newR1, newR2 := randUserRoleId(), randUserRoleId()
	err = m.BatchUpdate(ctx, []*SysUserRole{
		{Id: id1, UserId: userId, RoleId: newR1, CreateTime: ts, UpdateTime: newTs},
		{Id: id2, UserId: userId, RoleId: newR2, 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.UpdateTime != newTs || got1.RoleId != newR1 {
		t.Fatalf("got1 mismatch: %+v", got1)
	}
	got2, err := m.FindOne(ctx, id2)
	if err != nil {
		t.Fatalf("FindOne2: %v", err)
	}
	if got2.UpdateTime != newTs || got2.RoleId != newR2 {
		t.Fatalf("got2 mismatch: %+v", got2)
	}
}

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

	ts := time.Now().Unix()
	var ids []int64
	for i := 0; i < 3; i++ {
		res, err := m.Insert(ctx, &SysUserRole{
			UserId: randUserRoleId(), RoleId: randUserRoleId(), 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_user_role", 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 TestSysUserRoleModel_BatchDelete_Single(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", 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 TestSysUserRoleModel_BatchDelete_ContainsNonExist(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", 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 TestSysUserRoleModel_BatchInsertWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	u1 := randUserRoleId()
	r1, r2 := randUserRoleId(), randUserRoleId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.BatchInsertWithTx(c, session, []*SysUserRole{
			{UserId: u1, RoleId: r1, CreateTime: ts, UpdateTime: ts},
			{UserId: u1, RoleId: r2, CreateTime: ts, UpdateTime: ts},
		})
	})
	if err != nil {
		t.Fatalf("BatchInsertWithTx: %v", err)
	}
	got1, err := m.FindOneByUserIdRoleId(ctx, u1, r1)
	if err != nil {
		t.Fatalf("FindOne r1: %v", err)
	}
	got2, err := m.FindOneByUserIdRoleId(ctx, u1, r2)
	if err != nil {
		t.Fatalf("FindOne r2: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_user_role", got1.Id, got2.Id)
}

// TC-0340: 空列表
func TestSysUserRoleModel_BatchInsertWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(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, []*SysUserRole{})
	})
	if err != nil {
		t.Fatalf("BatchInsertWithTx empty: %v", err)
	}
}

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

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.BatchInsertWithTx(c, session, []*SysUserRole{
			{UserId: userId, RoleId: roleId, 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.FindOneByUserIdRoleId(ctx, userId, roleId)
	if err != ErrNotFound {
		t.Fatalf("after rollback want ErrNotFound got %v", err)
	}
}

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

	userId := randUserRoleId()
	r1, r2 := randUserRoleId(), randUserRoleId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: r1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert1: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: r2, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert2: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", id1, id2)

	newTs := ts + 200
	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.BatchUpdateWithTx(c, session, []*SysUserRole{
			{Id: id1, UserId: userId, RoleId: r1, CreateTime: ts, UpdateTime: newTs},
			{Id: id2, UserId: userId, RoleId: r2, 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.UpdateTime != newTs {
		t.Fatalf("got1 UpdateTime want %d got %d", newTs, got1.UpdateTime)
	}
}

// TC-0348: 空列表
func TestSysUserRoleModel_BatchUpdateWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(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, []*SysUserRole{})
	})
	if err != nil {
		t.Fatalf("BatchUpdateWithTx empty: %v", err)
	}
}

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

	ts := time.Now().Unix()
	var ids []int64
	for i := 0; i < 2; i++ {
		res, err := m.Insert(ctx, &SysUserRole{
			UserId: randUserRoleId(), RoleId: randUserRoleId(), 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_user_role", 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 TestSysUserRoleModel_BatchDeleteWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(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 TestSysUserRoleModel_FindOneWithTx_InsertThenFind(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	roleId := randUserRoleId()
	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, &SysUserRole{UserId: userId, RoleId: roleId, 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)
		require.NoError(t, err)
		assert.Equal(t, insertedId, got.Id)
		assert.Equal(t, userId, got.UserId)
		assert.Equal(t, roleId, got.RoleId)
		return nil
	})
	require.NoError(t, err)
	defer testutil.CleanTable(ctx, conn, "sys_user_role", insertedId)
}

// TC-0322: 事务内记录不存在
func TestSysUserRoleModel_FindOneWithTx_NotFound(t *testing.T) {
	ctx := context.Background()
	m := NewSysUserRoleModel(testutil.GetTestSqlConn(), 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-0389: FindOneByUserIdRoleIdWithTx
func TestSysUserRoleModel_FindOneByUserIdRoleIdWithTx_InsertThenFind(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	roleId := randUserRoleId()
	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, &SysUserRole{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
		if err != nil {
			return err
		}
		insertedId, err = res.LastInsertId()
		if err != nil {
			return err
		}
		got, err := m.FindOneByUserIdRoleIdWithTx(c, session, userId, roleId)
		require.NoError(t, err)
		assert.Equal(t, insertedId, got.Id)
		assert.Equal(t, userId, got.UserId)
		assert.Equal(t, roleId, got.RoleId)
		return nil
	})
	require.NoError(t, err)
	defer testutil.CleanTable(ctx, conn, "sys_user_role", insertedId)
}

// TC-0390: FindOneByUserIdRoleIdWithTx
func TestSysUserRoleModel_FindOneByUserIdRoleIdWithTx_NotFound(t *testing.T) {
	ctx := context.Background()
	m := NewSysUserRoleModel(testutil.GetTestSqlConn(), testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

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

// TC-0472: FindUserIdsByRoleId 正常返回角色下用户ID列表
func TestSysUserRoleModel_FindUserIdsByRoleId_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randUserRoleId()
	u1, u2 := randUserRoleId(), randUserRoleId()
	ts := time.Now().Unix()

	var ids []int64
	for _, userId := range []int64{u1, u2} {
		res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
		require.NoError(t, err)
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "sys_user_role", ids...) })

	got, err := m.FindUserIdsByRoleId(ctx, roleId)
	require.NoError(t, err)
	require.Len(t, got, 2)
	assert.True(t, int64SliceEqualIgnoreOrder(got, []int64{u1, u2}))
}

// TC-0473: FindUserIdsByRoleId 无绑定返回空
func TestSysUserRoleModel_FindUserIdsByRoleId_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	got, err := m.FindUserIdsByRoleId(context.Background(), 999999998)
	require.NoError(t, err)
	require.Empty(t, got)
}

// =============================================================================
// audit M-4 回归：FindRoleIdsByUserIdForProduct 必须过滤 r.status=1（禁用角色不返回）
// =============================================================================

// TC-0706: 同一产品下同时存在启用/禁用两个角色，接口只返回启用的那个
func TestSysUserRoleModel_FindRoleIdsByUserIdForProduct_FiltersDisabledRole(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	productCode := testutil.UniqueId()
	ts := time.Now().Unix()

	// 启用角色
	enabledRoleId := insertTestRole(t, ctx, conn, productCode, "enabled_"+testutil.UniqueId())
	// 禁用角色（默认 insertTestRole 状态=1，需要手动改为 2）
	disabledRoleId := insertTestRole(t, ctx, conn, productCode, "disabled_"+testutil.UniqueId())
	_, err := conn.ExecCtx(ctx, "UPDATE `sys_role` SET `status`=2 WHERE `id`=?", disabledRoleId)
	require.NoError(t, err)

	var recIds []int64
	for _, rid := range []int64{enabledRoleId, disabledRoleId} {
		res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: rid, CreateTime: ts, UpdateTime: ts})
		require.NoError(t, err)
		id, _ := res.LastInsertId()
		recIds = append(recIds, id)
	}
	defer func() {
		for _, id := range recIds {
			testutil.CleanTable(ctx, conn, "sys_user_role", id)
		}
		testutil.CleanTable(ctx, conn, "sys_role", enabledRoleId, disabledRoleId)
	}()

	got, err := m.FindRoleIdsByUserIdForProduct(ctx, userId, productCode)
	require.NoError(t, err)

	// 修复后：仅返回启用角色
	assert.ElementsMatch(t, []int64{enabledRoleId}, got,
		"audit M-4: FindRoleIdsByUserIdForProduct 必须过滤 r.status=1，禁用角色不应出现在返回中")
	assert.NotContains(t, got, disabledRoleId,
		"audit M-4: 禁用角色的 id 不应被返回")
}

// =============================================================================
// audit M-2 回归：DeleteByUserIdAndRoleIdsTx 批量删除正确性
// =============================================================================

// TC-0707: 批量删除指定 (userId, roleIds) 组合；未命中的绑定不受影响
func TestSysUserRoleModel_DeleteByUserIdAndRoleIdsTx(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	r1, r2, r3 := randUserRoleId(), randUserRoleId(), randUserRoleId()
	ts := time.Now().Unix()

	var recIds []int64
	for _, rid := range []int64{r1, r2, r3} {
		res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: rid, CreateTime: ts, UpdateTime: ts})
		require.NoError(t, err)
		id, _ := res.LastInsertId()
		recIds = append(recIds, id)
	}
	defer func() {
		for _, id := range recIds {
			testutil.CleanTable(ctx, conn, "sys_user_role", id)
		}
	}()

	// 删除 r1 和 r3，保留 r2
	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.DeleteByUserIdAndRoleIdsTx(c, session, userId, []int64{r1, r3})
	})
	require.NoError(t, err)

	got, err := m.FindRoleIdsByUserId(ctx, userId)
	require.NoError(t, err)
	assert.ElementsMatch(t, []int64{r2}, got, "仅保留未被删除的 r2")
}

// TC-0708: DeleteByUserIdAndRoleIdsTx 空列表时应立即返回 nil，不执行 SQL
func TestSysUserRoleModel_DeleteByUserIdAndRoleIdsTx_EmptyIsNoop(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()
	res, err := m.Insert(ctx, &SysUserRole{UserId: userId, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
	require.NoError(t, err)
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_role", id)

	// 空列表
	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.DeleteByUserIdAndRoleIdsTx(c, session, userId, []int64{})
	})
	require.NoError(t, err)

	// 原有绑定未被删除
	got, err := m.FindRoleIdsByUserId(ctx, userId)
	require.NoError(t, err)
	assert.Contains(t, got, roleId, "空 roleIds 列表不应删除任何数据")
}

// TC-0709: DeleteByUserIdAndRoleIdsTx 不影响其它 userId 的同 roleId 绑定（WHERE userId 约束）
func TestSysUserRoleModel_DeleteByUserIdAndRoleIdsTx_OtherUserNotAffected(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserRoleModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	u1, u2 := randUserRoleId(), randUserRoleId()
	roleId := randUserRoleId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysUserRole{UserId: u1, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
	require.NoError(t, err)
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysUserRole{UserId: u2, RoleId: roleId, CreateTime: ts, UpdateTime: ts})
	require.NoError(t, err)
	id2, _ := res2.LastInsertId()

	defer func() {
		testutil.CleanTable(ctx, conn, "sys_user_role", id1, id2)
	}()

	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.DeleteByUserIdAndRoleIdsTx(c, session, u1, []int64{roleId})
	})
	require.NoError(t, err)

	// u1 的被删，u2 的保留
	got1, _ := m.FindRoleIdsByUserId(ctx, u1)
	got2, _ := m.FindRoleIdsByUserId(ctx, u2)
	assert.NotContains(t, got1, roleId)
	assert.Contains(t, got2, roleId)
}