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

package robot

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"strings"

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

	"github.com/valyala/fastjson"
	"google.golang.org/protobuf/reflect/protoreflect"
)

const DefaultRobotFile = "robot.json"

type TestRobots struct {
	Count   int     `json:"count"`
	File    string  `json:"file"`
	Robot   string  `json:"robot"`
	Monitor bool    `json:"msg_monitor"` // 是否打印消息内容
	Ignores []int32 `json:"msg_ignore"`  // 忽略的消息清单
	Focus   []int32 `json:"msg_focus"`   // 只显示的msg，如果非空，则Ignores失效
}

type TestConfig struct {
	Config        string          `json:"config"`
	AccountPre    string          `json:"account_pre"`
	AccountOffset int32           `json:"account_off"`
	Server        string          `json:"server"`
	Brute         *BruteCnf       `json:"brutetest"`
	Statistic     StatisticConfig `json:"statistic"`
	Robots        []*TestRobots   `json:"robots"`
}

type BruteCnf struct {
	File       string `json:"file"`
	RobotCnt   int    `json:"robot_max"`
	File_Login string `json:"login_file"`
	Login      string `json:"case_login"`
	Relogin    string `json:"case_relogin"`
}

type StatisticConfig struct {
	StatisticTickInterval int64 `json:"stick"`
	StatisticTotTime      int64 `json:"stot"`
	ActionTimeOver        int64 `json:"action_timeover"`
}

const DefaultTestcaseFile = "testcase.json"

type TestCaseRunnerConfig struct {
	File  string `json:"file"`
	Do    string `json:"do"`
	Count int    `json:"count"`
}

type RobotConfig struct {
	Name         string
	Relogin      bool                    `json:"relogin"` // 如果true, 则断开连接后，会保存现场，先进行重连，然后进行login, 然后回复测试流程。 如果false，则直接清理退出
	File_Login   string                  `json:"login_file"`
	Case_Login   string                  `json:"case_login"`   // 登录case
	Case_Relogin string                  `json:"case_relogin"` // 重登case
	Cases        []*TestCaseRunnerConfig `json:"cases"`
}

type ProtoMsgConfig struct {
	Comment string      `json:"comment"` // 备注
	MsgId   int         `json:"msg_id"`  // 协议id
	Msg     interface{} `json:"msg"`     // 协议数据json字符串
}

type ProtoMsg struct {
	Name    string                    `json:"name"`
	Comment string                    `json:"comment"` // 备注
	MsgId   int                       `json:"msg_id"`  // 协议id
	Msg     protoreflect.ProtoMessage `json:"msg"`     // 协议数据json字符串
}

var MsgFactory map[int]protoreflect.ProtoMessage

var msg_cnf map[string]*ProtoMsgConfig
var MSG_DATA map[string]*ProtoMsg
var TESTCASE_CNF map[string]*ts.TestcaseConfig
var ROBOT_CNF map[string]*RobotConfig
var TEST_CNF TestConfig

var loadFiles = make(map[string]bool)

func testcaseCnfLoad(cnfPath string, file string) error {
	filename := fmt.Sprintf("%s%s", cnfPath, file)
	if _, ok := loadFiles[filename]; ok {
		// 已经加载
		return nil
	}
	loadFiles[filename] = true

	var readFile []byte
	readFile, err := ioutil.ReadFile(filename)
	if err != nil {
		return fmt.Errorf("TestCase:%s ReadFile err:%s", filename, err.Error())
	}

	j, err := fastjson.ParseBytes(readFile)
	if err != nil {
		return fmt.Errorf("TestCase:%s jsonParse err:%s", filename, err.Error())
	}

	objs, err := j.Object()
	if err != nil {
		return fmt.Errorf("TestCase:%s Object Root err:%s", filename, err.Error())
	}

	var errBuilder strings.Builder
	bErr := false
	objs.Visit(func(tsK []byte, tsV *fastjson.Value) {
		tfs := tsV.GetArray("testflows")
		if tfs == nil {
			bErr = true
			errBuilder.WriteString(fmt.Sprintf("TestCase:%s %s without testflows\n", filename, tsK))
			return
		}

		tsCnf := ts.TestcaseConfig{
			Name:     string(tsK),
			TestFlow: make([][]ts.TestcaseActionCnf, 0),
		}

		for tfK, tfV := range tfs {
			tf := tfV.GetArray()
			var tfCnf []ts.TestcaseActionCnf
			for aK, aV := range tf {
				aName := aV.GetStringBytes("name")
				f, ok := ts.TESTCASEACTION_MGR.Find(string(aName))
				if !ok {
					if err == nil {
						bErr = true
						errBuilder.WriteString(fmt.Sprintf("TestCase:%s %s[%d][%d] Action:%s nil\n", filename, tsK, tfK, aK, aName))
					} else {
						bErr = true
						errBuilder.WriteString(fmt.Sprintf("TestCase:%s %s\n%s[%d][%d] Action:%s nil\n", filename, err.Error(), tsK, tfK, aK, aName))
					}

					return
				}

				aCnf := f.Cnf()
				errUnmarshal := json.Unmarshal([]byte(aV.String()), aCnf)
				if errUnmarshal != nil {
					if err == nil {
						bErr = true
						errBuilder.WriteString(fmt.Sprintf("TestCase:%s %s[%d][%d] Action:%s Unmarshal err:%s\n", filename, tsK, tfK, aK, aName, errUnmarshal.Error()))
					} else {
						bErr = true
						errBuilder.WriteString(fmt.Sprintf("TestCase:%s %s\n%s[%d][%d] Action:%s Unmarshal err:%s\n", filename, err.Error(), tsK, tfK, aK, aName, errUnmarshal.Error()))
					}
					return
				}

				tfCnf = append(tfCnf, aCnf)
			}
			tsCnf.TestFlow = append(tsCnf.TestFlow, tfCnf)
		}

		TESTCASE_CNF[fmt.Sprintf("%s/%s", file, string(tsK))] = &tsCnf
	})

	if bErr {
		return fmt.Errorf(errBuilder.String())
	}

	return nil
}

func robotDescLoad(cnfPath string, file string) error {
	filename := fmt.Sprintf("%s%s", cnfPath, file)
	if _, ok := loadFiles[filename]; ok {
		// 已经加载
		return nil
	}
	loadFiles[filename] = true

	readFile, err := ioutil.ReadFile(filename)
	if err != nil {
		return fmt.Errorf("RobotConfig:%s ReadFile err:%s", filename, err.Error())
	}

	robotCnf := make(map[string]*RobotConfig)
	err = json.Unmarshal(readFile, &robotCnf)
	if err != nil {
		return fmt.Errorf("RobotConfig:%s Unmarshal err:%s", filename, err.Error())
	}

	var errBuilder strings.Builder
	bErr := false
	for n, c := range robotCnf {
		if c.File_Login == "" {
			c.File_Login = DefaultTestcaseFile
		}
		err = testcaseCnfLoad(cnfPath, c.File_Login)
		if err != nil {
			bErr = true
			errBuilder.WriteString(fmt.Sprintf("RobotConfig:%s File_Login:%s testcaseCnfLoad err:%s\n", filename, c.File_Login, err.Error()))
		}

		for _, t := range c.Cases {
			if t.File == "" {
				t.File = DefaultTestcaseFile
			}
			err = testcaseCnfLoad(cnfPath, t.File)
			if err != nil {
				bErr = true
				errBuilder.WriteString(fmt.Sprintf("RobotConfig:%s case:%s testcaseCnfLoad err:%s\n", filename, t.File, err.Error()))
			}
		}

		ROBOT_CNF[fmt.Sprintf("%s/%s", file, n)] = c
	}

	if bErr {
		return fmt.Errorf(errBuilder.String())
	}

	return nil
}

func ConfigLoad(cnfPath string, config string) error {
	readFile, err := ioutil.ReadFile(fmt.Sprintf("%s%s", cnfPath, config))
	if err != nil {
		return err
	}

	err = json.Unmarshal(readFile, &TEST_CNF)
	if err != nil {
		return err
	}

	// 进行robot文件加载
	var errBuilder strings.Builder
	bErr := false
	ROBOT_CNF = make(map[string]*RobotConfig)
	TESTCASE_CNF = make(map[string]*ts.TestcaseConfig)
	if TEST_CNF.Brute != nil {
		if TEST_CNF.Brute.File_Login == "" {
			TEST_CNF.Brute.File_Login = DefaultTestcaseFile
		}

		err = testcaseCnfLoad(cnfPath, TEST_CNF.Brute.File_Login)
		if err != nil {
			bErr = true
			errBuilder.WriteString(fmt.Sprintf("Brute File_Login:%s testcaseCnfLoad err:%s\n", TEST_CNF.Brute.File_Login, err.Error()))
		}
	}

	for _, r := range TEST_CNF.Robots {
		if r.File == "" {
			r.File = DefaultRobotFile
		}
		err = robotDescLoad(cnfPath, r.File)
		if err != nil {
			errBuilder.WriteString(fmt.Sprintln(err.Error()))
			bErr = true
		}
	}

	if bErr {
		return fmt.Errorf(errBuilder.String())
	}

	return nil
}

func ProtoMsgLoad(cnfPath string) error {
	msg_cnf = make(map[string]*ProtoMsgConfig)
	MSG_DATA = make(map[string]*ProtoMsg)

	readFile, err := ioutil.ReadFile(fmt.Sprintf("%sproto_msg.json", cnfPath))
	if err != nil {
		return err
	}
	err = json.Unmarshal(readFile, &msg_cnf)
	if err != nil {
		return err
	}

	for key, cnf := range msg_cnf {
		msg_bytes, err := json.Marshal(cnf.Msg)
		if err != nil {
			return err
		}

		msgP, ok := MsgFactory[cnf.MsgId]
		if !ok {
			return fmt.Errorf("msgId:%d nil", cnf.MsgId)
		}

		msg := msgP.ProtoReflect().New().Interface()
		err = json.Unmarshal(msg_bytes, msg)
		if err != nil {
			return err
		}

		MSG_DATA[key] = &ProtoMsg{
			Name:    key,
			Comment: cnf.Comment,
			MsgId:   cnf.MsgId,
			Msg:     msg,
		}
	}
	return nil
}

func ProtoMsgSave(file string, data map[string]*ProtoMsg) error {
	out, err := json.Marshal(data)
	if err != nil {
		return err
	}

	err = ioutil.WriteFile(file, out, 0666)
	return err
}