devstar/models/wechat/wechat_test.go

package wechat_test

import (
	"context"
	"fmt"
	"testing"
	"time"

	"code.gitea.io/gitea/models/db"
	"code.gitea.io/gitea/models/unittest"
	user_model "code.gitea.io/gitea/models/user"
	"code.gitea.io/gitea/models/wechat"
	"code.gitea.io/gitea/modules/setting"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestMain(m *testing.M) {

	setupWechatConfig()
	// 运行主测试
	unittest.MainTest(m, &unittest.TestOptions{})
}

func setupWechatConfig() {
	// 只设置必要的UserConfig部分
	setting.Wechat.UserConfig = setting.WechatUserConfigType{
		AppID: "test_appid",
	}
}
func createTestUser(t *testing.T) *user_model.User {
	// 创建测试用户
	user := &user_model.User{
		Name:      fmt.Sprintf("testuser_%d", time.Now().UnixNano()),
		LowerName: fmt.Sprintf("testuser_%d", time.Now().UnixNano()),
		Email:     "test@example.com",
		IsActive:  true,
	}
	_, err := db.GetEngine(db.DefaultContext).Insert(user)
	require.NoError(t, err)
	return user
}

func TestQueryUserByOpenid(t *testing.T) {
	// 准备数据库
	require.NoError(t, unittest.PrepareTestDatabase())
	// 设置微信配置
	setupWechatConfig()
	// 创建数据库上下文
	ctx := context.Background()

	// 创建一个测试用户
	user := createTestUser(t)

	// 测试用例：正常查询
	t.Run("正常查询", func(t *testing.T) {
		openid := "test_openid_1"
		// 插入绑定数据
		_, err := db.GetEngine(ctx).Insert(&wechat.UserWechatOpenid{
			Uid:         user.ID,
			WechatAppid: setting.Wechat.UserConfig.AppID,
			Openid:      openid,
		})
		require.NoError(t, err)

		// 执行查询
		result, err := wechat.QueryUserByOpenid(ctx, openid)
		assert.NoError(t, err)
		assert.Equal(t, user.ID, result.ID)
	})

	// 测试用例：用户不存在
	t.Run("用户不存在", func(t *testing.T) {
		_, err := wechat.QueryUserByOpenid(ctx, "non_exist_openid")
		assert.Error(t, err)
		assert.IsType(t, wechat.ErrWechatOfficialAccountUserNotExist{}, err)
	})

	// 测试用例：用户被禁用
	t.Run("用户被禁用", func(t *testing.T) {
		// 创建被禁用的用户
		disabledUser := createTestUser(t)
		disabledUser.Name = "disabled" + disabledUser.Name
		disabledUser.LowerName = "Isdisabled" + disabledUser.LowerName
		disabledUser.ProhibitLogin = true
		err := user_model.UpdateUserCols(ctx, disabledUser, "prohibit_login")
		assert.NoError(t, err)

		// 插入禁用用户的绑定信息
		openid := "test_openid_disabled"
		_, err = db.GetEngine(db.DefaultContext).Insert(&wechat.UserWechatOpenid{
			Uid:         disabledUser.ID,
			WechatAppid: setting.Wechat.UserConfig.AppID,
			Openid:      openid,
		})
		assert.NoError(t, err)

		// 执行查询
		_, err = wechat.QueryUserByOpenid(ctx, openid)
		assert.Error(t, err)
		assert.IsType(t, user_model.ErrUserProhibitLogin{}, err)
	})
}

func TestUpdateOrCreateWechatUser(t *testing.T) {
	// 准备数据库
	assert.NoError(t, unittest.PrepareTestDatabase())
	// 设置微信配置
	setupWechatConfig()
	// 创建数据库上下文
	ctx := context.Background()

	// 创建一个用户用于绑定
	user := createTestUser(t)
	openid := "test_openid_update"

	// 测试用例：创建新绑定
	t.Run("创建新绑定", func(t *testing.T) {
		err := wechat.UpdateOrCreateWechatUser(ctx, user, openid)
		assert.NoError(t, err)

		// 验证数据库记录
		var binding wechat.UserWechatOpenid
		has, err := db.GetEngine(ctx).Where("uid = ?", user.ID).Get(&binding)
		assert.NoError(t, err)
		assert.True(t, has)
		assert.Equal(t, openid, binding.Openid)
		assert.Equal(t, setting.Wechat.UserConfig.AppID, binding.WechatAppid)
	})

	// 测试用例：更新已有绑定
	t.Run("更新已有绑定", func(t *testing.T) {
		newOpenid := "updated_openid"
		err := wechat.UpdateOrCreateWechatUser(ctx, user, newOpenid)
		assert.NoError(t, err)

		// 验证更新
		var binding wechat.UserWechatOpenid
		has, err := db.GetEngine(ctx).Where("uid = ?", user.ID).Get(&binding)
		assert.NoError(t, err)
		assert.True(t, has)
		assert.Equal(t, newOpenid, binding.Openid)
	})

	// 测试用例：绑定信息未变化
	t.Run("绑定信息未变化", func(t *testing.T) {
		// 先确保有绑定记录
		err := wechat.UpdateOrCreateWechatUser(ctx, user, openid)
		assert.NoError(t, err)

		// 再次绑定相同信息
		err = wechat.UpdateOrCreateWechatUser(ctx, user, openid)
		assert.NoError(t, err)

		// 验证没有重复记录
		count, err := db.GetEngine(ctx).Where("uid = ?", user.ID).Count(&wechat.UserWechatOpenid{})
		assert.NoError(t, err)
		assert.Equal(t, int64(1), count)
	})
}

func TestDeleteWechatUser(t *testing.T) {
	// 准备数据库
	assert.NoError(t, unittest.PrepareTestDatabase())
	// 设置微信配置
	setupWechatConfig()
	// 创建数据库上下文
	ctx := context.Background()

	// 创建一个用户用于删除绑定
	user := createTestUser(t)
	openid := "test_openid_delete"

	// 测试用例：正常删除
	t.Run("正常删除", func(t *testing.T) {
		// 先创建绑定
		err := wechat.UpdateOrCreateWechatUser(ctx, user, openid)
		assert.NoError(t, err)

		// 执行删除
		err = wechat.DeleteWechatUser(ctx, user)
		assert.NoError(t, err)

		// 验证删除
		var binding wechat.UserWechatOpenid
		has, err := db.GetEngine(ctx).Where("uid = ?", user.ID).Get(&binding)
		assert.NoError(t, err)
		assert.False(t, has)
	})

	// 测试用例：删除不存在绑定
	t.Run("删除不存在绑定", func(t *testing.T) {
		// 确保没有绑定记录
		_, _ = db.GetEngine(ctx).Where("uid = ?", user.ID).Delete(&wechat.UserWechatOpenid{})

		// 执行删除
		err := wechat.DeleteWechatUser(ctx, user)
		assert.NoError(t, err) // 删除不存在的记录应视为成功
	})

	// 测试用例：无效用户
	t.Run("无效用户", func(t *testing.T) {
		invalidUser := &user_model.User{ID: -1}
		err := wechat.DeleteWechatUser(ctx, invalidUser)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "User and its ID cannot be nil")
	})

	// 测试用例：空用户
	t.Run("空用户", func(t *testing.T) {
		err := wechat.DeleteWechatUser(ctx, nil)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "User and its ID cannot be nil")
	})
}