gitee.com/KyleChenSource/lib-robot@v1.0.2/robottest/testcaseimp/lua.go

package testcaseimp

// Lua文件返回表
// {onStart, onMsg, onTimer, onStop}
// 会在对应时机进行函数调用
// 本身提供函数给Lua调用
//	CtxGet(ctx LuaScript, key string)
//	CtxSet(ctx LuaScript, key string, value)
//	MsgRegister(ctx LuaScript, msgId)
//	MsgUnRegister(ctx LuaScript, msgId)
//	TimeRegister(ctx LuaScript, delay, key, cb)
//	TimeUnRegister(ctx LuaScript, key)
//	SendMsgWithCnf(ctx, file, key)
//	SendMsg(ctx, msgId, data)
// 	ActionEnd(ctx, string)

import (
	"fmt"
	"math"
	"math/rand"
	"sync"

	"gitee.com/KyleChenSource/lib-robot/robottest/robot/testcase"
	lua "github.com/yuin/gopher-lua"

	"gitee.com/KyleChenSource/lib-robot/robottest/protos"

	"gitee.com/KyleChenSource/lib-robot/robottest/log"

	"gitee.com/KyleChenSource/lib-robot/robottest/common"
	"gitee.com/KyleChenSource/lib-robot/robottest/common/mlua"
)

type LuaScriptFactory struct {
}

type LuaScriptCnf struct {
	testcase.TestcaseActionConfig_
	LuaFile string `json:"file"`
}

func (this *LuaScriptFactory) Cnf() testcase.TestcaseActionCnf {
	return &LuaScriptCnf{}
}

func (this *LuaScriptFactory) New(id testcase.TestActionID, tf testcase.ITestFlow, cnf testcase.TestcaseActionCnf) (testcase.ITestcaseAction, error) {
	return &LuaScript{
		_id:  id,
		_tf:  tf,
		_cnf: cnf.(*LuaScriptCnf),
	}, nil
}

func init() {
	testcase.TESTCASEACTION_MGR.Register("LuaScript", &LuaScriptFactory{})
}

var (
	luaFiles sync.Map
)

type LuaScript struct {
	_id       testcase.TestActionID
	_tf       testcase.ITestFlow
	_cnf      *LuaScriptCnf
	_delay    *common.TimeInterface
	_timerCbs map[*common.TimeInterface]*lua.LFunction
	_timers   map[string]*common.TimeInterface
	_msgIds   map[int]bool
	luaScript *mlua.LuaScript
	luaMe     *lua.LUserData
}

// 启动
// 目前仅仅支持定时器和消息两种驱动模式
func (this *LuaScript) Start() error {
	var L *mlua.LuaCtx
	if l, ok := this._tf.TestCtx().Get("Lua"); !ok {
		L = mlua.LuaCtxCreate()
		L.L.SetGlobal("CtxGet", L.L.NewFunction(ctxGet))
		L.L.SetGlobal("CtxSet", L.L.NewFunction(ctxSet))
		L.L.SetGlobal("MsgRegister", L.L.NewFunction(registerMsg))
		L.L.SetGlobal("MsgUnRegister", L.L.NewFunction(unRegisterMsg))
		L.L.SetGlobal("TimeRegister", L.L.NewFunction(registerTimer))
		L.L.SetGlobal("TimeUnRegister", L.L.NewFunction(unRegisterTimer))
		L.L.SetGlobal("ActionEnd", L.L.NewFunction(actionEnd))

		L.L.SetGlobal("SendMsgWithCnf", L.L.NewFunction(sendMsgWithCnf))
		L.L.SetGlobal("SendMsg", L.L.NewFunction(sendMsg))
		this._tf.TestCtx().Set("Lua", L)
	} else {
		L = l.(*mlua.LuaCtx)
	}

	var err error
	this.luaScript, err = L.Script(this._cnf.LuaFile)
	if err != nil {
		return fmt.Errorf("script:%s err:%s", this._cnf.LuaFile, err.Error())
	}

	this.luaMe = L.L.NewUserData()
	this.luaMe.Value = this

	this._timerCbs = make(map[*common.TimeInterface]*lua.LFunction)
	this._timers = make(map[string]*common.TimeInterface)
	this._msgIds = make(map[int]bool)

	delay := int64(this._cnf.Delay)
	if this._cnf.RandMin > 0 {
		delay += (*this._cnf).RandMin
	}
	if this._cnf.RandMax > this._cnf.RandMin {
		delay += rand.Int63n((*this._cnf).RandMax - (*this._cnf).RandMin)
	}

	if delay > 0 {
		t, err := this._tf.TestCtx().TimerAdd(delay, this.OnTimerStart, nil)
		if err != nil {
			return err
		}
		this._delay = t
		log.LogInfo("%s action:%d delay:%d", this._tf.LogPre(), this._id, delay)
	} else {
		this.onStart()
	}

	return nil
}

func (this *LuaScript) onStart() {
	log.LogInfo("%s action:%d onStart", this._tf.LogPre(), this._id)
	t, _ := this._tf.TestCtx().Get("Lua")
	l := t.(*mlua.LuaCtx)

	topB := l.L.GetTop()
	err := l.L.CallByParam(lua.P{Fn: this.luaScript.OnStart, NRet: 1, Protect: true},
		this.luaMe,
	)

	if err != nil {
		this._tf.OnActionEnd(this, fmt.Errorf("onStart:%s", err.Error()), this._cnf.FailContinue)
		return
	}

	topN := l.L.GetTop()
	if topN-topB != 1 {
		this._tf.OnActionEnd(this, fmt.Errorf("onStart return:%d", topN-topB), this._cnf.FailContinue)
		return
	}
	ret := l.L.Get(topN)
	if ret.Type() != lua.LTNil {
		if ret.Type() == lua.LTString {
			this._tf.OnActionEnd(this, fmt.Errorf("onStart return err:%s", ret.String()), this._cnf.FailContinue)
			return
		}
		this._tf.OnActionEnd(this, fmt.Errorf("onStart return type:%d value:%s", ret.Type(), ret.String()), this._cnf.FailContinue)
		return
	}

	l.L.Pop(topN - topB)
}

// 停止，需要删除目前所有的驱动注册
func (this *LuaScript) Stop() {
	for timer, _ := range this._timerCbs {
		this._tf.TestCtx().TimerDel(timer)
	}

	for msgid, _ := range this._msgIds {
		this._tf.TestCtx().MsgHandleUnreg(protos.ProtoID(msgid), this)
	}
}

func (this *LuaScript) ID() testcase.TestActionID {
	return this._id
}

func (this *LuaScript) Name() string {
	return this._cnf.ActionName()
}

func (this *LuaScript) Testflow() testcase.ITestFlow {
	return this._tf
}

func (this *LuaScript) OnMsg(protoId protos.ProtoID, header protos.JsonString, data protos.JsonString) {
	t, _ := this._tf.TestCtx().Get("Lua")
	l := t.(*mlua.LuaCtx)

	topB := l.L.GetTop()
	err := l.L.CallByParam(lua.P{Fn: this.luaScript.OnMsg, NRet: 1, Protect: true},
		this.luaMe,
		lua.LNumber(protoId),
		lua.LString(data),
	)

	if err != nil {
		this._tf.OnActionEnd(this, fmt.Errorf("OnMsg:%s", err.Error()), this._cnf.FailContinue)
		return
	}

	topN := l.L.GetTop()
	if topN-topB != 1 {
		this._tf.OnActionEnd(this, fmt.Errorf("OnMsg return:%d", topN-topB), this._cnf.FailContinue)
		return
	}
	ret := l.L.Get(topN)
	if ret.Type() != lua.LTNil {
		if ret.Type() == lua.LTString {
			this._tf.OnActionEnd(this, fmt.Errorf("OnMsg return err:%s", ret.String()), this._cnf.FailContinue)
			return
		}
		this._tf.OnActionEnd(this, fmt.Errorf("OnMsg return type:%d value:%s", ret.Type(), ret.String()), this._cnf.FailContinue)
		return
	}

	l.L.Pop(topN - topB)
}

func (this *LuaScript) OnTimerStart(timer *common.TimeInterface, data any) int64 {
	this._delay = nil

	this.onStart()
	return 0
}

func (this *LuaScript) OnTimerLua(timer *common.TimeInterface, data any) (nextTimer int64) {
	nextTimer = 0
	t, _ := this._tf.TestCtx().Get("Lua")
	l := t.(*mlua.LuaCtx)

	function, ok := this._timerCbs[timer]
	if !ok {
		this._tf.OnActionEnd(this, fmt.Errorf("OnTimerLua no cb"), this._cnf.FailContinue)
		return 0
	}
	topB := l.L.GetTop()
	err := l.L.CallByParam(lua.P{Fn: function, NRet: 2, Protect: true},
		this.luaMe,
	)

	if err != nil {
		this._tf.OnActionEnd(this, fmt.Errorf("OnTimerLua err:%s", err.Error()), this._cnf.FailContinue)
		return 0
	}

	topN := l.L.GetTop()
	if topN-topB != 2 {
		this._tf.OnActionEnd(this, fmt.Errorf("OnMsg return:%d", topN-topB), this._cnf.FailContinue)
		return 0
	}

	nextTimer = int64(l.L.ToNumber(topB + 1))
	if nextTimer <= 0 {
		delete(this._timerCbs, timer)
		for key, v := range this._timers {
			if v == timer {
				delete(this._timers, key)
				break
			}
		}
	}

	ret := l.L.Get(topN)
	if ret.Type() != lua.LTNil {
		if ret.Type() == lua.LTString {
			this._tf.OnActionEnd(this, fmt.Errorf("OnMsg return err:%s", ret.String()), this._cnf.FailContinue)
			return
		}
		this._tf.OnActionEnd(this, fmt.Errorf("onStart return type:%d", ret.Type()), this._cnf.FailContinue)
		return
	}

	return
}

func registerMsg(L *lua.LState) int {
	//a *ActionLua, id int
	a := L.CheckUserData(1)
	if a == nil {
		L.Push(lua.LString("param 0 not UserData"))
		return 1
	}
	this, ok := a.Value.(*LuaScript)
	if !ok {
		L.Push(lua.LString(fmt.Sprintf("param 0 not LuaScript:%T", a.Value)))
		return 1
	}

	id := int(L.ToNumber(2))
	this._tf.TestCtx().MsgHandleReg(protos.ProtoID(id), this)
	this._msgIds[id] = true
	return 0
}

func unRegisterMsg(L *lua.LState) int {
	//a *ActionLua, id int
	a := L.CheckUserData(1)
	if a == nil {
		L.Push(lua.LString("param 0 not UserData"))
		return 1
	}
	this, ok := a.Value.(*LuaScript)
	if !ok {
		L.Push(lua.LString(fmt.Sprintf("param 0 not LuaScript:%T", a.Value)))
		return 1
	}

	id := int(L.ToNumber(2))
	this._tf.TestCtx().MsgHandleUnreg(protos.ProtoID(id), this)
	delete(this._msgIds, id)
	return 0
}

func registerTimer(L *lua.LState) int {
	//a *ActionLua, string for functioin name
	a := L.CheckUserData(1)
	if a == nil {
		L.Push(lua.LString("param 0 not UserData"))
		return 1
	}
	this, ok := a.Value.(*LuaScript)
	if !ok {
		L.Push(lua.LString(fmt.Sprintf("param 0 not LuaScript:%T", a.Value)))
		return 1
	}

	delay := int64(L.ToNumber(2))
	key := L.ToString(3)
	function := L.ToFunction(4)

	t, err := this._tf.TestCtx().TimerAdd(delay, this.OnTimerLua, nil)
	if err != nil {
		L.Push(lua.LString(fmt.Sprintf("time Add Failed:%s", err.Error())))
		return 1
	}

	this._timerCbs[t] = function
	this._timers[key] = t
	return 0
}

func unRegisterTimer(L *lua.LState) int {
	//a *ActionLua, string for functioin name
	a := L.CheckUserData(1)
	if a == nil {
		L.Push(lua.LString("param 0 not UserData"))
		return 1
	}
	this, ok := a.Value.(*LuaScript)
	if !ok {
		L.Push(lua.LString(fmt.Sprintf("param 0 not LuaScript:%T", a.Value)))
		return 1
	}

	key := L.ToString(2)
	timer, ok := this._timers[key]
	if !ok {
		L.Push(lua.LString(fmt.Sprintf("timer:%s nil", key)))
		return 1
	}

	this._tf.TestCtx().TimerDel(timer)

	delete(this._timers, key)
	delete(this._timerCbs, timer)
	return 0
}

func actionEnd(L *lua.LState) int {
	//a *ActionLua, string
	a := L.CheckUserData(1)
	if a == nil {
		L.Push(lua.LString("param 0 not UserData"))
		return 1
	}
	this, ok := a.Value.(*LuaScript)
	if !ok {
		L.Push(lua.LString(fmt.Sprintf("param 0 not LuaScript:%T", a.Value)))
		return 1
	}

	key := L.ToString(2)
	if len(key) == 0 {
		this._tf.OnActionEnd(this, nil, this._cnf.FailContinue)
	} else {
		this._tf.OnActionEnd(this, fmt.Errorf(key), this._cnf.FailContinue)
	}
	return 0
}

func ctxGet(L *lua.LState) int {
	//a *ActionLua, string
	a := L.CheckUserData(1)
	if a == nil {
		L.Push(lua.LString("param 0 not UserData"))
		return 1
	}
	this, ok := a.Value.(*LuaScript)
	if !ok {
		L.Push(lua.LString(fmt.Sprintf("param 0 not LuaScript:%T", a.Value)))
		return 1
	}

	key := L.ToString(2)
	v, ok := this._tf.TestCtx().Get(key)
	if !ok {
		L.Push(lua.LBool(true))
		L.Push(lua.LNil)
		return 2
	}

	switch x := v.(type) {
	case int:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case int8:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case int16:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case int32:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case int64:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case uint:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case uint8:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case uint16:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case uint32:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case uint64:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case float32:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case float64:
		L.Push(lua.LBool(ok))
		L.Push(lua.LNumber(x))
		return 2
	case string:
		L.Push(lua.LBool(ok))
		L.Push(lua.LString(x))
		return 2
	case bool:
		L.Push(lua.LBool(ok))
		L.Push(lua.LBool(x))
		return 2
	}

	L.Push(lua.LBool(false))
	return 1
}

func ctxSet(L *lua.LState) int {
	//a *ActionLua, string
	a := L.CheckUserData(1)
	if a == nil {
		L.Push(lua.LString("param 0 not UserData"))
		return 1
	}
	this, ok := a.Value.(*LuaScript)
	if !ok {
		L.Push(lua.LString(fmt.Sprintf("param 0 not LuaScript:%T", a.Value)))
		return 1
	}

	ok = false
	key := L.ToString(2)
	value := L.Get(3)
	switch value.Type() {
	case lua.LTNumber:
		f := float64(lua.LVAsNumber(value))
		x := math.Trunc(f)
		if x == f {
			this._tf.TestCtx().Set(key, int64(x))
		} else {
			this._tf.TestCtx().Set(key, f)
		}
		ok = true
	case lua.LTString:
		this._tf.TestCtx().Set(key, lua.LVAsString(value))
		ok = true
	case lua.LTFunction:
		this._tf.TestCtx().Set(key, value.(*lua.LFunction))
		ok = true
	case lua.LTTable:
		this._tf.TestCtx().Set(key, value.(*lua.LTable))
		ok = true
	case lua.LTChannel:
	case lua.LTUserData:
	case lua.LTThread:
	}

	L.Push(lua.LBool(ok))
	return 1
}

func sendMsgWithCnf(L *lua.LState) int {
	//a *ActionLua, string
	a := L.CheckUserData(1)
	if a == nil {
		L.Push(lua.LString("param 0 not UserData"))
		return 1
	}
	this, ok := a.Value.(*LuaScript)
	if !ok {
		L.Push(lua.LString(fmt.Sprintf("param 0 not LuaScript:%T", a.Value)))
		return 1
	}

	ok = false
	file := L.ToString(2)
	key := L.ToString(3)

	pCnf, err := protos.NetworkProtoData(file, key)
	if err != nil {
		L.Push(lua.LString(fmt.Sprintf("NetworkProtoData err:%s", err.Error())))
		return 1
	}

	if pCnf == nil {
		L.Push(lua.LString(fmt.Sprintf("file:%s key:%s nil", file, key)))
		return 1
	}

	// 实现json数据替换
	data, err := protos.JsonReplace(pCnf.Data, this._tf.TestCtx())
	if err != nil {
		L.Push(lua.LString(fmt.Sprintf("JsonReplace err:%s", err.Error())))
		return 1
	}

	err = this._tf.TestCtx().Send(pCnf.ID, data)
	if err != nil {
		L.Push(lua.LString(fmt.Sprintf("Send err:%s", err.Error())))
		return 1
	}

	log.LogInfo("%s action:%d msgSend:%d data:%s", this._tf.LogPre(), this._id, pCnf.ID, data)
	return 0
}

func sendMsg(L *lua.LState) int {
	//a *ActionLua, string
	a := L.CheckUserData(1)
	if a == nil {
		L.Push(lua.LString("param 0 not UserData"))
		return 1
	}
	this, ok := a.Value.(*LuaScript)
	if !ok {
		L.Push(lua.LString(fmt.Sprintf("param 0 not LuaScript:%T", a.Value)))
		return 1
	}

	ok = false
	msgId := protos.ProtoID(L.ToNumber(2))
	data := protos.JsonString(L.ToString(3))

	err := this._tf.TestCtx().Send(msgId, data)
	if err != nil {
		L.Push(lua.LString(fmt.Sprintf("Send err:%s", err.Error())))
		return 1
	}

	log.LogInfo("%s action:%d msgSend:%d data:%s", this._tf.LogPre(), this._id, msgId, data)
	return 0
}