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

package testcaseimp

import (
	"fmt"
	"math/rand"
	"time"

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

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

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

type MonitorMsg struct {
	MsgId protos.ProtoID    `json:"msg_id"`
	Sets  map[string]string `json:"sets"` // 对消息进行设置
}

type ProtoSendWaitCnf struct {
	testcase.TestcaseActionConfig_

	MsgFile string `json:"msg_file"` // 协议的配置文件
	MsgKey  string `json:"msg_key"`  // 协议的文件中的key

	MonitorMsgs []MonitorMsg   `json:"monitor_msgs"`
	ResponseId  protos.ProtoID `json:"response_id"` // 预期返回协议ID, 0无返回
	Timeout     int            `json:"timeout"`     // 预期等待时间，单位ms. ResponseId != 0时有效

	CheckFailedExit bool `json:"check_failexit"` // 是否检测失败就Action失败
	// 预期返回协议的校验. ResponseId != 0时有效. key -> value
	// key: Respone协议校验路径
	// value: 对应路径校验逻辑判定
	// 具体参考logic.y注释说明
	// 关键字：	 Length(容器长度)
	//			Value当前值
	//			None： Value==nil
	// 操作符：	<, <=, ==, >, >=
	// 			&&, ||, not
	Checks map[string]protos.CheckData `json:"checks"`
}

type ProtoSendWaitFactory struct {
}

func (this *ProtoSendWaitFactory) Cnf() testcase.TestcaseActionCnf {
	return &ProtoSendWaitCnf{}
}

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

func init() {
	testcase.TESTCASEACTION_MGR.Register("ProtoSendWait", &ProtoSendWaitFactory{})
}

type ProtoSendWait struct {
	_id       testcase.TestActionID
	_tf       testcase.ITestFlow
	_cnf      *ProtoSendWaitCnf
	_timer    *common.TimeInterface
	_timeSend int64 // 发送时间
}

// 启动
// 目前仅仅支持定时器和消息两种驱动模式
func (this *ProtoSendWait) Start() error {
	for _, m := range this._cnf.MonitorMsgs {
		this._tf.TestCtx().MsgHandleReg(m.MsgId, this)
	}

	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 {
		log.LogDebug("%s delay:%d", this._tf.LogPre(), delay)
		t, err := this._tf.TestCtx().TimerAdd(delay, this.OnTimerMsgSend, nil)

		if err != nil {
			return err
		}

		this._timer = t
		return nil
	}

	this.msgSend()

	return nil
}

// 停止，需要删除目前所有的驱动注册
func (this *ProtoSendWait) Stop() {
	if this._timer != nil {
		this._tf.TestCtx().TimerDel(this._timer)
	}

	if this._cnf.ResponseId > 0 {
		this._tf.TestCtx().MsgHandleUnreg(this._cnf.ResponseId, this)
	}

	for _, m := range this._cnf.MonitorMsgs {
		this._tf.TestCtx().MsgHandleUnreg(m.MsgId, this)
	}
}

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

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

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

func (this *ProtoSendWait) onMonitor(protoId protos.ProtoID, header protos.JsonString, data protos.JsonString) {
	for _, m := range this._cnf.MonitorMsgs {
		if m.MsgId != protoId {
			continue
		}

		err := protos.JsonSet(string(data), &m.Sets, this._tf.TestCtx())
		if err != nil {
			log.LogError("MsgMonitor SetErr. %s action:%d OnMsg:%d header:%s data:%s err:%s", this._tf.LogPre(), this._id, protoId, header, data, err.Error())
			this._tf.OnActionEnd(this, err, this._cnf.FailContinue)
			return
		}

		log.LogInfo("MsgMonitor OK. %s action:%d OnMsg:%d header:%s data:%s", this._tf.LogPre(), this._id, protoId, header, data)
	}
}

func (this *ProtoSendWait) OnMsg(protoId protos.ProtoID, header protos.JsonString, data protos.JsonString) {
	tCost := time.Now().UnixMilli() - this._timeSend

	if protoId != this._cnf.ResponseId {
		this.onMonitor(protoId, header, data)
		return
	}

	if len(this._cnf.Checks) > 0 {
		b, bContinue, err := protos.JsonCheck(string(data), this._cnf.Checks, this._tf.TestCtx())
		if err != nil {
			log.LogError("MsgResponse CheckErr. %s action:%d OnMsg:%d header:%s data:%s timeCost:%d err:%s", this._tf.LogPre(), this._id, protoId, header, data, tCost, err.Error())
			statistic.Record(&statistic.StatisticEvent{
				Type: statistic.StatisticType_Msg_Err,
				ID:   int(protoId),
			})
			this._tf.OnActionEnd(this, err, this._cnf.FailContinue)
			return
		}

		if !b {
			if !bContinue {
				log.LogError("MsgResponse CheckFailed. %s action:%d OnMsg:%d header:%s data:%s timeCost:%d", this._tf.LogPre(), this._id, protoId, header, data, tCost)
				statistic.Record(&statistic.StatisticEvent{
					Type: statistic.StatisticType_Msg_Fail,
					ID:   int(protoId),
				})
				this._tf.OnActionEnd(this, fmt.Errorf("checks failed"), this._cnf.FailContinue)
			}
			return
		}
	}

	this.onMonitor(protoId, header, data)
	log.LogInfo("MsgResponse OK. %s action:%d OnMsg:%d header:%s data:%s timeCost:%d", this._tf.LogPre(), this._id, protoId, header, data, tCost)
	this._tf.OnActionEnd(this, nil, this._cnf.FailContinue)

	statistic.Record(&statistic.StatisticEvent{
		Type: statistic.StatisticType_Msg_Success,
		ID:   int(protoId),
		Time: tCost,
	})
}

func (this *ProtoSendWait) end(err error) {
	this._tf.OnActionEnd(this, err, this._cnf.FailContinue)
}

func (this *ProtoSendWait) msgSend() {
	pCnf, err := protos.NetworkProtoData(this._cnf.MsgFile, this._cnf.MsgKey)
	if err != nil {
		this._tf.OnActionEnd(this, fmt.Errorf("%s SendMsg %s:%s err:%s", this._cnf.Name, this._cnf.MsgFile, this._cnf.MsgKey, err.Error()), this._cnf.FailContinue)
		return
	}

	if pCnf == nil {
		this._tf.OnActionEnd(this, fmt.Errorf("%s SendMsg %s:%s NULL", this._cnf.Name, this._cnf.MsgFile, this._cnf.MsgKey), this._cnf.FailContinue)
		return
	}

	// 实现json数据替换
	data, err := protos.JsonReplace(pCnf.Data, this._tf.TestCtx())
	if err != nil {
		this._tf.OnActionEnd(this, fmt.Errorf("%s JsonReplace %s:%s err:%s", this._cnf.Name, this._cnf.MsgFile, this._cnf.MsgKey, err.Error()), this._cnf.FailContinue)
		return
	}

	err = this._tf.TestCtx().Send(pCnf.ID, data)
	if err != nil {
		this._tf.OnActionEnd(this, fmt.Errorf("%s SendMsg %s:%s err:%s", this._cnf.Name, this._cnf.MsgFile, this._cnf.MsgKey, err.Error()), this._cnf.FailContinue)
		return
	}

	log.LogInfo("%s action:%d msgSend:%d data:%s", this._tf.LogPre(), this._id, pCnf.ID, data)
	// 发送成功，开始等待需要的回包
	if this._cnf.Timeout == 0 && this._cnf.ResponseId == 0 {
		// 结束
		statistic.Record(&statistic.StatisticEvent{
			Type: statistic.StatisticType_Msg_Success,
			ID:   int(pCnf.ID),
			Time: 0,
		})
		this.end(nil)
		return
	}

	if this._cnf.ResponseId > 0 {
		this._tf.TestCtx().MsgHandleReg(this._cnf.ResponseId, this)
	}

	if this._cnf.Timeout > 0 {
		log.LogDebug("%s timeOut:%d", this._tf.LogPre(), this._cnf.Timeout)
		// 定时器超时
		t, err := this._tf.TestCtx().TimerAdd(int64(this._cnf.Timeout), this.OnTimerResponseTimeout, nil)

		if err != nil {
			this.end(err)
			return
		}

		this._timer = t
	}

	this._timeSend = time.Now().UnixMilli()
}

func (this *ProtoSendWait) OnTimerMsgSend(t *common.TimeInterface, data any) int64 {
	log.LogInfo("action:%d OnTimerMsgSend\n", this.ID())
	this._timer = nil

	this.msgSend()
	return 0
}

func (this *ProtoSendWait) OnTimerResponseTimeout(t *common.TimeInterface, data any) int64 {
	log.LogInfo("MsgResponse Timeout. %s action:%d OnMsg:%d timeOut:%d", this._tf.LogPre(), this._id, this._cnf.ResponseId, this._cnf.Timeout)
	this._timer = nil

	this._tf.OnActionEnd(this, fmt.Errorf("timeout:%d msg:%d", this._cnf.Timeout, this._cnf.ResponseId), this._cnf.FailContinue)
	statistic.Record(&statistic.StatisticEvent{
		Type: statistic.StatisticType_Msg_Timeout,
		ID:   int(this._cnf.ResponseId),
	})
	return 0
}