You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
473 lines
13 KiB
473 lines
13 KiB
package runcase
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
"automatedtesting/usecases_server/models"
|
|
"automatedtesting/usecases_server/utils/cyllib/log"
|
|
"automatedtesting/usecases_server/utils/cyllib/re"
|
|
"automatedtesting/usecases_server/utils/cyllib/serial"
|
|
sorket "automatedtesting/usecases_server/utils/cyllib/socket"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"gorm.io/gorm"
|
|
// "usecases_server/utils/cyllib/socket"
|
|
)
|
|
|
|
type RunCaseParam struct {
|
|
Com string `json:"com,omitempty"`
|
|
IdList string `json:"idlist,omitempty"`
|
|
ClintIp string `json:"clintip,omitempty"`
|
|
Gid string `json:"gid,omitempty"`
|
|
// 给前端返回数据时，判断的标志
|
|
Key string `json:"key"`
|
|
Flag bool `json:"flag"`
|
|
Val interface{} `json:"val"`
|
|
}
|
|
|
|
/**
|
|
* 前后端协议：
|
|
* connect 连接是否成功
|
|
* senial 串口连接是否成功
|
|
*/
|
|
var SocketMap = make(map[string]*RunCases) //socket全局
|
|
|
|
func MapIsKey(dict map[string]*RunCases, key string) bool {
|
|
if _, ok := dict[key]; ok {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (s *RunCaseController) CaseSorket(c *gin.Context) {
|
|
|
|
id_str := c.Query("id")
|
|
var runcase *RunCases
|
|
wbskt := sorket.NewWebSocket()
|
|
runcase = NewRunCase()
|
|
runcase.WebSocket = wbskt
|
|
if !wbskt.Connect(c.Writer, c.Request) {
|
|
return
|
|
}
|
|
runcase.Id = id_str
|
|
runcase.ConnectFlag = true
|
|
SocketMap[id_str] = runcase
|
|
// defer wbskt.Close()
|
|
runcase.sendSocketData("connect", true, "")
|
|
fmt.Println("连接成功......")
|
|
go s.RunCaseSorket(c, id_str)
|
|
|
|
}
|
|
|
|
func (s *RunCaseController) RunCaseSorket(c *gin.Context, id_str string) {
|
|
|
|
for {
|
|
dataByte, flag := SocketMap[id_str].WebSocket.ReadBytes()
|
|
if !flag {
|
|
fmt.Println("socket断开")
|
|
goto Loop
|
|
} else {
|
|
dict := RunCaseParam{}
|
|
json.Unmarshal(dataByte, &dict)
|
|
SocketMap[id_str].Param = dict
|
|
// fmt.Println(dict)
|
|
if dict.Key == "stop" && dict.Flag {
|
|
goto Loop
|
|
} else if dict.Key == "run" && dict.Flag {
|
|
// fmt.Println("运行用例")
|
|
SocketMap[id_str].RunFlag = true
|
|
SocketMap[id_str].RunCase(id_str)
|
|
}
|
|
}
|
|
time.Sleep(1000 * time.Millisecond)
|
|
}
|
|
Loop:
|
|
SocketMap[id_str].WebSocket.Close()
|
|
SocketMap[id_str].ConnectFlag = false
|
|
SocketMap[id_str].RunFlag = false
|
|
fmt.Println("退出socket")
|
|
}
|
|
|
|
type RunCases struct {
|
|
Id string
|
|
Param RunCaseParam
|
|
RunFlag bool
|
|
ConnectFlag bool
|
|
WebSocket *sorket.WebSocket
|
|
Socket *sorket.SocKetOsi
|
|
RealResult string
|
|
}
|
|
|
|
type WbData struct {
|
|
Com string `json:"com"`
|
|
Idlist []int `json:"idlist"`
|
|
}
|
|
|
|
func NewRunCase() *RunCases {
|
|
r := RunCases{}
|
|
return &r
|
|
}
|
|
|
|
func (s *RunCases) sendSocketData(key string, flag bool, val interface{}) {
|
|
par := RunCaseParam{}
|
|
par.Key = key
|
|
par.Flag = flag
|
|
par.Val = val
|
|
s.WebSocket.SendJson(par)
|
|
}
|
|
|
|
type steps struct {
|
|
Id int `json:"id"`
|
|
Indexes int `json:"indexes"`
|
|
Step string `json:"step"`
|
|
Expect string `json:"expect"`
|
|
}
|
|
type deftims struct {
|
|
DefWaitTime int `json:"def_wait_time"`
|
|
DefBetweenTime int `json:"def_between_time"`
|
|
}
|
|
type tims struct {
|
|
WaitTime int `json:"wait_time"`
|
|
BetweenTime int `json:"between_time"`
|
|
}
|
|
|
|
func (s *RunCases) RunCase(id_str string) bool {
|
|
wbdata := WbData{}
|
|
json.Unmarshal([]byte(s.Param.Val.(string)), &wbdata)
|
|
s.Param.Com = wbdata.Com
|
|
// 获取有步骤
|
|
steps := []steps{}
|
|
if err := models.GetDb().Table("cases").Where("id in ?", wbdata.Idlist).Order("id").Find(&steps).Error; err != nil {
|
|
log.WriteErr(err)
|
|
}
|
|
// 获取默认等待时间
|
|
deftims := deftims{}
|
|
if err := models.GetDb().Table("groups").Where("id = ?", id_str).First(&deftims).Error; err != nil {
|
|
log.WriteErr(err)
|
|
}
|
|
// 获取等待时间
|
|
waittime := []models.WaitTime{}
|
|
if err := models.GetDb().Table("waittime").Where("gid = ?", id_str).Find(&waittime).Error; err != nil {
|
|
log.WriteErr(err)
|
|
}
|
|
// 获取用例总数
|
|
var count int64 = 0
|
|
if err := models.GetDb().Table("cases").Where("gid = ?", id_str).Count(&count).Error; err != nil {
|
|
log.WriteErr(err)
|
|
}
|
|
models.GetDb().Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Table("groups").Where("id = ?", id_str).Updates(models.Groups{ExeTime: time.Now()}).Error; err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
// 运行用例
|
|
go func() {
|
|
cot := 0
|
|
for _, data := range steps {
|
|
if s.ConnectFlag {
|
|
s.RealResult = ""
|
|
Tf := ""
|
|
// cas:=models.Cases{}
|
|
flag := s.RunOne(data, deftims, &waittime)
|
|
if flag {
|
|
Tf = "T"
|
|
cot++
|
|
} else {
|
|
Tf = "F"
|
|
}
|
|
models.GetDb().Transaction(func(tx *gorm.DB) error {
|
|
s.RealResult = strings.TrimRight(s.RealResult,"\r\n")
|
|
if err := tx.Table("cases").Where("id = ?", data.Id).Updates(models.Cases{Result: Tf, Real: s.RealResult}).Error; err != nil {
|
|
tx.Rollback()
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
var succcount int64 = 0
|
|
if err := models.GetDb().Table("cases").Where("gid = ? and result = ?", id_str, "T").Count(&succcount).Error; err != nil {
|
|
log.WriteErr(err)
|
|
}
|
|
var sen = make(map[string]interface{})
|
|
sen["count"] = count
|
|
sen["succ"] = succcount
|
|
sen["fail"] = count - succcount
|
|
sen["rate"] = int64((succcount * 100) / count)
|
|
sen["mcount"] = len(wbdata.Idlist)
|
|
sen["msucc"] = cot
|
|
sen["mrate"] = int64((cot * 100) / len(wbdata.Idlist))
|
|
|
|
s.sendSocketData("rate", true, sen)
|
|
|
|
} else {
|
|
goto Loop
|
|
}
|
|
}
|
|
Loop:
|
|
s.sendSocketData("run", false, "")
|
|
s.WebSocket.Close()
|
|
}()
|
|
return false
|
|
}
|
|
|
|
func (s *RunCases) RunOne(stp steps, deftime deftims, waittime *[]models.WaitTime) bool {
|
|
exp := `\d+\..+[\r\n]?(?:(?!\d+\.).*[\r\n]?)*`
|
|
steplist := re.FindAll2(exp, stp.Step)
|
|
explist := re.FindAll2(exp, stp.Expect)
|
|
tims := tims{
|
|
WaitTime: deftime.DefWaitTime,
|
|
BetweenTime: deftime.DefBetweenTime,
|
|
}
|
|
for i, _ := range steplist {
|
|
step_ := re.FindAll(`\d+\.([\w\W]*)`, steplist[i])
|
|
exp_ := re.FindAll(`\d+\.([\w\W]*)`, explist[i])
|
|
if len(step_) > 0 && len(step_[0]) > 1 && len(exp) > 0 && len(exp_[0]) > 1 {
|
|
step := step_[0][1]
|
|
exp := exp_[0][1]
|
|
for _, d := range *waittime {
|
|
if strings.Contains(step, d.ChildModule) {
|
|
tims.WaitTime = d.WaitTime
|
|
tims.BetweenTime = d.BetweenTime
|
|
goto Loop
|
|
}
|
|
}
|
|
Loop:
|
|
if !s.DealSerial(stp.Indexes, i, step, exp, tims) {
|
|
return false
|
|
}
|
|
// fmt.Println(step_[0][1], " ", exp_[0][1])
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
|
|
}
|
|
|
|
func (s *RunCases) DealSerial(index, i int, step, exp string, tims tims) bool {
|
|
|
|
var sen = make(map[string]interface{})
|
|
sen["index"] = index
|
|
sen["step"] = step
|
|
s.sendSocketData("step", false, sen)
|
|
ch, _ := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(tims.WaitTime)) //Duration(tims.WaitTime)
|
|
str := ""
|
|
flag := false
|
|
getstr, getexp := "", ""
|
|
se, err := serial.OpenSerial(s.Param.Com, serial.ModeDef)
|
|
if err != nil {
|
|
s.sendSocketData("serial", false, "")
|
|
s.WebSocket.Close()
|
|
return false
|
|
}
|
|
se.WriteString(step + "\n") //发送数据
|
|
for {
|
|
select {
|
|
case <-ch.Done():
|
|
// fmt.Println("等待超时")
|
|
goto Loop
|
|
default:
|
|
str += se.ReadString()
|
|
}
|
|
flag = matching(str, exp, &getstr, &getexp)
|
|
if flag {
|
|
goto Loop
|
|
}
|
|
}
|
|
Loop:
|
|
time.Sleep(time.Millisecond * time.Duration(tims.BetweenTime))
|
|
se.Close()
|
|
s.RealResult = fmt.Sprint(s.RealResult, i+1, ".", str, "\r\n")
|
|
|
|
log.Infof("******************************************************************************")
|
|
log.Infof("**********************************序号%v***************************************", index)
|
|
log.Infof("%v、%v|result:%v", i+1, step, flag)
|
|
log.Infof("期望结果|%v", exp)
|
|
log.Infof("实际结果|%v", str)
|
|
log.Infof("匹配时期望字符串|%v", getexp)
|
|
log.Infof("匹配时结果字符串|%v", getstr)
|
|
return flag
|
|
}
|
|
func matching(str, exp string, getstr, getexp *string) bool { //, getstr, getexp *string
|
|
|
|
exp = strings.ReplaceAll(exp, "\n", "")
|
|
exp = strings.ReplaceAll(exp, "\r", "")
|
|
|
|
str = strings.ReplaceAll(str, "\n", "")
|
|
str = strings.ReplaceAll(str, "\r", "")
|
|
|
|
str = strings.ToUpper(str)
|
|
exp = strings.ToUpper(exp)
|
|
|
|
*getstr = str
|
|
*getexp = exp
|
|
|
|
if strings.Contains(str, exp) {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
// // ----------------------------------------------------------------------------以上被抛弃
|
|
// func RunCase(id_str string) bool {
|
|
// // wbdata := WbData{}
|
|
// // json.Unmarshal([]byte(s.Param.Val.(string)), &wbdata)
|
|
// // s.Param.Com = wbdata.Com
|
|
// // 获取有步骤
|
|
// steps := []steps{}
|
|
// if err := models.GetDb().Table("cases").Where("id in ?", wbdata.Idlist).Order("id").Find(&steps).Error; err != nil {
|
|
// log.WriteErr(err)
|
|
// }
|
|
// // 获取默认等待时间
|
|
// deftims := deftims{}
|
|
// if err := models.GetDb().Table("groups").Where("id = ?", id_str).First(&deftims).Error; err != nil {
|
|
// log.WriteErr(err)
|
|
// }
|
|
// // 获取等待时间
|
|
// waittime := []models.WaitTime{}
|
|
// if err := models.GetDb().Table("waittime").Where("gid = ?", id_str).Find(&waittime).Error; err != nil {
|
|
// log.WriteErr(err)
|
|
// }
|
|
// // 获取用例总数
|
|
// var count int64 = 0
|
|
// if err := models.GetDb().Table("cases").Where("gid = ?", id_str).Count(&count).Error; err != nil {
|
|
// log.WriteErr(err)
|
|
// }
|
|
// models.GetDb().Transaction(func(tx *gorm.DB) error {
|
|
// if err := tx.Table("groups").Where("id = ?", id_str).Updates(models.Groups{ExeTime: time.Now()}).Error; err != nil {
|
|
// tx.Rollback()
|
|
// return err
|
|
// }
|
|
// return nil
|
|
// })
|
|
// // 运行用例
|
|
// go func() {
|
|
// cot := 0
|
|
// for _, data := range steps {
|
|
// RealResult := ""
|
|
// Tf := ""
|
|
// // cas:=models.Cases{}
|
|
// flag := RunOne(data, deftims, &waittime)
|
|
// if flag {
|
|
// Tf = "T"
|
|
// cot++
|
|
// } else {
|
|
// Tf = "F"
|
|
// }
|
|
// models.GetDb().Transaction(func(tx *gorm.DB) error {
|
|
// RealResult = strings.TrimRight(RealResult,"\r\n")
|
|
// if err := tx.Table("cases").Where("id = ?", data.Id).Updates(models.Cases{Result: Tf, Real: RealResult}).Error; err != nil {
|
|
// tx.Rollback()
|
|
// return err
|
|
// }
|
|
// return nil
|
|
// })
|
|
// var succcount int64 = 0
|
|
// if err := models.GetDb().Table("cases").Where("gid = ? and result = ?", id_str, "T").Count(&succcount).Error; err != nil {
|
|
// log.WriteErr(err)
|
|
// }
|
|
// var sen = make(map[string]interface{})
|
|
// sen["count"] = count
|
|
// sen["succ"] = succcount
|
|
// sen["fail"] = count - succcount
|
|
// sen["rate"] = int64((succcount * 100) / count)
|
|
// sen["mcount"] = len(wbdata.Idlist)
|
|
// sen["msucc"] = cot
|
|
// sen["mrate"] = int64((cot * 100) / len(wbdata.Idlist))
|
|
|
|
// // s.sendSocketData("rate", true, sen)-----
|
|
|
|
|
|
// }
|
|
// }()
|
|
// return false
|
|
// }
|
|
// func RunOne(stp steps, deftime deftims, waittime *[]models.WaitTime) bool {
|
|
// exp := `\d+\..+[\r\n]?(?:(?!\d+\.).*[\r\n]?)*`
|
|
// steplist := re.FindAll2(exp, stp.Step)
|
|
// explist := re.FindAll2(exp, stp.Expect)
|
|
// tims := tims{
|
|
// WaitTime: deftime.DefWaitTime,
|
|
// BetweenTime: deftime.DefBetweenTime,
|
|
// }
|
|
// for i, _ := range steplist {
|
|
// step_ := re.FindAll(`\d+\.([\w\W]*)`, steplist[i])
|
|
// exp_ := re.FindAll(`\d+\.([\w\W]*)`, explist[i])
|
|
// if len(step_) > 0 && len(step_[0]) > 1 && len(exp) > 0 && len(exp_[0]) > 1 {
|
|
// step := step_[0][1]
|
|
// exp := exp_[0][1]
|
|
// for _, d := range *waittime {
|
|
// if strings.Contains(step, d.ChildModule) {
|
|
// tims.WaitTime = d.WaitTime
|
|
// tims.BetweenTime = d.BetweenTime
|
|
// goto Loop
|
|
// }
|
|
// }
|
|
// Loop:
|
|
// if !DealSerial(stp.Indexes, i, step, exp, tims) {
|
|
// return false
|
|
// }
|
|
// // fmt.Println(step_[0][1], " ", exp_[0][1])
|
|
// } else {
|
|
// return false
|
|
// }
|
|
// }
|
|
// return true
|
|
// }
|
|
// func DealSerial(index, i int, step, exp string, tims tims) bool {
|
|
|
|
// var sen = make(map[string]interface{})
|
|
// sen["index"] = index
|
|
// sen["step"] = step
|
|
// // s.sendSocketData("step", false, sen)---------------
|
|
// ch, _ := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(tims.WaitTime)) //Duration(tims.WaitTime)
|
|
// str := ""
|
|
// flag := false
|
|
// getstr, getexp := "", ""
|
|
// se, err := serial.OpenSerial(s.Param.Com, serial.ModeDef)
|
|
// if err != nil {
|
|
// s.sendSocketData("serial", false, "")
|
|
// s.WebSocket.Close()
|
|
// return false
|
|
// }
|
|
// se.WriteString(step + "\n") //发送数据
|
|
// for {
|
|
// select {
|
|
// case <-ch.Done():
|
|
// // fmt.Println("等待超时")
|
|
// goto Loop
|
|
// default:
|
|
// str += se.ReadString()
|
|
// }
|
|
// flag = matching(str, exp, &getstr, &getexp)
|
|
// if flag {
|
|
// goto Loop
|
|
// }
|
|
// }
|
|
// Loop:
|
|
// time.Sleep(time.Millisecond * time.Duration(tims.BetweenTime))
|
|
// se.Close()
|
|
// s.RealResult = fmt.Sprint(s.RealResult, i+1, ".", str, "\r\n")
|
|
|
|
// log.Infof("******************************************************************************")
|
|
// log.Infof("**********************************序号%v***************************************", index)
|
|
// log.Infof("%v、%v|result:%v", i+1, step, flag)
|
|
// log.Infof("期望结果|%v", exp)
|
|
// log.Infof("实际结果|%v", str)
|
|
// log.Infof("匹配时期望字符串|%v", getexp)
|
|
// log.Infof("匹配时结果字符串|%v", getstr)
|
|
// return flag
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|