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

package testcaseimp

import (
	"fmt"
	"time"

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

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

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

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

type ProtoWaitSendCnf struct {
	WaitId      protos.ProtoID `json:"wait_id"`      // 预期返回协议ID, 0无返回
	WaitTimeout int            `json:"wait_timeout"` // 预期等待时间，单位ms. ResponseId != 0时有效

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

	ProtoSendWaitCnf
}

type ProtoWaitSendFactory struct {
}

func (this *ProtoWaitSendFactory) Cnf() testcase.TestcaseActionCnf {
	return &ProtoWaitSendCnf{}
}

func (this *ProtoWaitSendFactory) New(id testcase.TestActionID, tf testcase.ITestFlow, cnf testcase.TestcaseActionCnf) (testcase.ITestcaseAction, error) {
	return &ProtoWaitSend{
		_id:    id,
		_tf:    tf,
		_cnf:   cnf.(*ProtoWaitSendCnf),
		_state: ProtoWaitSendState_Wait,
	}, nil
}

func init() {
	testcase.TESTCASEACTION_MGR.Register("ProtoWaitSend", &ProtoWaitSendFactory{})
}

type ProtoWaitSendState int

const (
	ProtoWaitSendState_Wait ProtoWaitSendState = iota // 初始化
	ProtoWaitSendState_Send
)

type ProtoWaitSend struct {
	_id       testcase.TestActionID
	_tf       testcase.ITestFlow
	_cnf      *ProtoWaitSendCnf
	_state    ProtoWaitSendState
	_timer    *common.TimeInterface
	_timeSend int64 // 发送时间
}

// 启动
// 目前仅仅支持定时器和消息两种驱动模式
func (this *ProtoWaitSend) Start() error {
	if this._cnf.WaitId <= 0 {
		return fmt.Errorf("wait_id:%d", this._cnf.WaitId)
	}

	this._tf.TestCtx().MsgHandleReg(this._cnf.WaitId, this)

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

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

		if err != nil {
			this.end(err)
			return fmt.Errorf("wait_time err:%s", err.Error())
		}

		this._timer = t
	}

	return nil
}

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

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

	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 *ProtoWaitSend) ID() testcase.TestActionID {
	return this._id
}

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

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

func (this *ProtoWaitSend) 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 *ProtoWaitSend) OnMsg(protoId protos.ProtoID, header protos.JsonString, data protos.JsonString) {
	log.LogDebug("%s action:%d OnMsg:%d header:%s data:%s", this._tf.LogPre(), this._id, protoId, header, data)

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

	switch this._state {
	case ProtoWaitSendState_Wait:
		if protoId != this._cnf.WaitId {
			log.LogError("%s action:%d OnMsg:%d header:%s data:%s err:id not %d", this._tf.LogPre(), this._id, protoId, header, data, protoId)
			this._tf.OnActionEnd(this, fmt.Errorf("id not %d", protoId), this._cnf.FailContinue)
			return
		}

		b, _, err := protos.JsonCheck(string(data), this._cnf.WaitChecks, this._tf.TestCtx())
		if err != nil {
			return
		}

		if !b {
			return
		}

		this._tf.TestCtx().MsgHandleUnreg(this._cnf.WaitId, this)
		this._tf.TestCtx().MsgHandleReg(this._cnf.ResponseId, this)

		this.onMonitor(protoId, header, data)

		// 检测成功，发消息了
		this.msgSend()
		return
	case ProtoWaitSendState_Send:
		tCost := time.Now().UnixMilli() - this._timeSend
		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 *ProtoWaitSend) end(err error) {
	this._tf.OnActionEnd(this, err, this._cnf.FailContinue)
}

func (this *ProtoWaitSend) msgSend() {
	if this._state != ProtoWaitSendState_Wait {
		this._tf.OnActionEnd(this, fmt.Errorf("%s SendMsg %s:%s err:state is %d", this._cnf.Name, this._cnf.MsgFile, this._cnf.MsgKey, this._state), this._cnf.FailContinue)
		return
	}

	if this._timer != nil {
		this._tf.TestCtx().TimerDel(this._timer)
		this._timer = nil
	}

	this._state = ProtoWaitSendState_Send
	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.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 *ProtoWaitSend) OnTimerWaitTimeout(t *common.TimeInterface, data any) int64 {
	log.LogInfo("Wait Timeout. %s action:%d OnMsg:%d timeOut:%d", this._tf.LogPre(), this._id, this._cnf.WaitId, this._cnf.WaitTimeout)
	this._timer = nil

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

func (this *ProtoWaitSend) 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
}