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

package testcaseimp

/*
	实现交互模拟发包功能
	file(f) filename: 指定发包使用的文件
	out(o) filename:指定消息格式化输出的文件
	generator(g) msgid [msgkey]: 生成指定msgId消息, 默认msgid_default作为key
	send(s) msgkey: 发送file的指定key消息
	exit(e) [error]: 退出action, 默认error = nil
*/

import (
	"flag"
	"fmt"
	"regexp"
	"strconv"
	"strings"

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

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

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

type InteractionCnf struct {
	testcase.TestcaseActionConfig_
}

type InteractionFactory struct {
}

func (this *InteractionFactory) Cnf() testcase.TestcaseActionCnf {
	return &InteractionCnf{}
}

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

func init() {
	testcase.TESTCASEACTION_MGR.Register("Interaction", &InteractionFactory{})
}

type Interaction struct {
	_id       testcase.TestActionID
	_tf       testcase.ITestFlow
	_cnf      *InteractionCnf
	_timer    *common.TimeInterface
	_timeSend int64 // 发送时间
	_monitors []protos.ProtoID
}

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

	log.LogInfo("%s Interval:%d", this._tf.LogPre(), this._cnf.Interval)
	t, err := this._tf.TestCtx().TimerAdd(int64(this._cnf.Interval), this.OnTimer, nil)
	if err != nil {
		return err
	}
	this._timer = t
	interaction.Input().Want()

	return nil
}

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

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

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

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

func (this *Interaction) OnMsg(protoId protos.ProtoID, header protos.JsonString, data protos.JsonString) {
	fmt.Printf("\n收到协议 %d: %s\n$请输入指令", protoId, data)
}

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

func (this *Interaction) monitor(idsstring string) []protos.ProtoID {
	ids := strings.Split(strings.Trim(idsstring, " "), "|")
	if len(ids) > 0 {
		for _, id := range this._monitors {
			this._tf.TestCtx().MsgHandleUnreg(id, this)
		}

		this._monitors = this._monitors[:0]
		for _, idstring := range ids {
			id, err := strconv.ParseInt(idstring, 0, 32)
			if err != nil {
				fmt.Printf("%s id:%s not protoid", idsstring, idstring)
				continue
			}
			this._tf.TestCtx().MsgHandleReg(protos.ProtoID(id), this)
			this._monitors = append(this._monitors, protos.ProtoID(id))
		}
	}

	return this._monitors
}

func (this *Interaction) msgSend(file string, key string) error {
	pCnf, err := protos.NetworkProtoData(file, key)
	if err != nil {
		return err
	}

	if pCnf == nil {
		return fmt.Errorf("proto not found")
	}

	// 实现json数据替换
	data, err := protos.JsonReplace(pCnf.Data, this._tf.TestCtx())
	if err != nil {
		return err
	}

	err = this._tf.TestCtx().Send(pCnf.ID, data)
	if err != nil {
		return err
	}

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

func (this *Interaction) OnTimer(t *common.TimeInterface, data any) int64 {
	// log.LogDebug("action:%d OnTimer\n", this.ID())
	oldTimer := this._timer
	this._timer = nil

	var line string
	exit := false
	input := false
	select {
	case line = <-interaction.Input().Line():
		input = true

	default:
	}

	if input {
		exit = cmdExe(line, this)
		if exit {
			return 0
		}

		interaction.Input().Want()
	}

	// 继续timer
	this._timer = oldTimer
	return int64(this._cnf.Interval)
}

var (
	cmdSplit = regexp.MustCompile(" +")
	file     = "interaction.json"
	out      = "record.json"
)

func cmdExe(arg string, action *Interaction) (exit bool) {
	s := flag.NewFlagSet("cmdExe", flag.ContinueOnError)

	bFile := s.Bool("file", false, "file(f) -filename(fn) name: 重新载入发包使用的协议文件")
	s.BoolVar(bFile, "f", false, "file(f) -filename(fn) name: 重新载入发包使用的协议文件")
	fileCmd := s.String("filename", file, "file(f) -filename(fn) name: 重新载入发包使用的协议文件")
	s.StringVar(fileCmd, "fn", file, "file(f) -filename(fn) name: 重新载入发包使用的协议文件")

	outCmd := s.String("out", "", "out(o) filename:指定消息格式化输出的文件")
	s.StringVar(outCmd, "o", "", "out(o) filename:指定消息格式化输出的文件")
	gen := s.Bool("generator", false, "generator(g) -id msgid [-key msg_key]: 生成指定msgId消息, 默认msgid_default作为key")
	s.BoolVar(gen, "g", false, "generator(g) -id msgid [-key msg_key]: 生成指定msgId消息, 默认msgid_default作为key")
	msgid := s.Int("id", 0, "generator(g) -id msgid [-key msg_key]: 生成指定msgId消息, 默认msgid_default作为key")
	s.IntVar(msgid, "i", 0, "generator(g) -id msgid [-key msg_key]: 生成指定msgId消息, 默认msgid_default作为key")
	msgkey := s.String("key", "", "generator(g) -id msgid [-key msg_key]: 生成指定msgId消息, 默认msgid_default作为key")
	s.StringVar(msgkey, "k", "", "generator(g) -id msgid [-key msg_key]: 生成指定msgId消息, 默认msgid_default作为key")
	send := s.String("send", "", "send(s) msgkey: 发送file的指定key消息")
	s.StringVar(send, "s", "", "send(s) msgkey: 发送file的指定key消息")

	bMonitor := s.Bool("monitor", false, "monitor(m) -ids(is) msgid|....: 指定打印的消息内容，如果参数为空，显示当前监控的消息列表")
	s.BoolVar(bMonitor, "m", false, "monitor(m) -ids(is) msgid|....: 指定打印的消息内容，如果参数为空，显示当前监控的消息列表")
	monitor := s.String("ids", "", "monitor(m) -ids(is) msgid|....: 指定打印的消息内容，如果参数为空，显示当前监控的消息列表")
	s.StringVar(monitor, "is", "", "monitor(m) -ids(is) msgid|....: 指定打印的消息内容，如果参数为空，显示当前监控的消息列表")

	s.BoolVar(&exit, "exit", false, "exit(e) -error reason]: 退出action, 默认error = nil")
	s.BoolVar(&exit, "ex", false, "exit(e) -error reason]: 退出action, 默认error = nil")
	exitReason := s.String("error", "", "exit(e) [error]: 退出action, 默认error = nil")
	s.StringVar(exitReason, "er", "", "exit(e) [error]: 退出action, 默认error = nil")

	args := cmdSplit.Split(strings.Trim(arg, " \n"), -1)
	if args[0] != "-" {
		args[0] = "-" + args[0]
	}

	err := s.Parse(args)
	if err != nil {
		fmt.Printf("input %v err:%s\n", args, err.Error())
		return
	}

	if *bFile {
		// 执行file
		protos.FileReload(*fileCmd)
		err := protos.FileSave(*fileCmd)
		if err != nil {
			fmt.Printf("%s读取错误, err:%s\n", *fileCmd, err.Error())
		} else {
			file = *fileCmd
			fmt.Printf("发包使用配置文件:%s\n", file)
		}
	}

	if len(*outCmd) > 0 {
		err := protos.FileSave(*outCmd)
		if err != nil {
			fmt.Printf("%s读取错误, err:%s\n", *outCmd, err.Error())
		} else {
			out = *outCmd
			fmt.Printf("输出的文件:%s\n", out)
		}
	}

	if *gen {
		if *msgid == 0 {
			s.Usage()
		} else {
			err := protos.NetworkProtoGen(file, protos.ProtoID(*msgid), *msgkey)
			if err != nil {
				fmt.Printf("生成protoid:%d err:%s\n", *msgid, err.Error())
			}
		}
	}

	if *bMonitor {
		if len(*monitor) > 0 {
			action.monitor(*monitor)
		}

		fmt.Print("监控的协议:")
		for _, id := range action._monitors {
			fmt.Printf(" %d", id)
		}
		fmt.Print("\n")
	}

	if len(*send) > 0 {
		err := action.msgSend(file, *send)
		if err != nil {
			fmt.Printf("发送协议 %s protoid:%d err:%s\n", file, *msgid, err.Error())
		}
	}

	if exit {
		if len(*exitReason) > 0 {
			action.end(fmt.Errorf(*exitReason))
		} else {
			action.end(nil)
		}
	}

	return
}