xg_autotest/internal/auto/auto.go

package auto

import (
	"bufio"
	"database/sql"
	"fmt"
	"math/rand"
	"os"
	"strings"
	"time"
	"xgAutoTest/internal/config"
	"xgAutoTest/internal/dbBase"
	"xgAutoTest/internal/global"
	"xgAutoTest/internal/produce"
	"xgAutoTest/internal/utils"
)

// var textsList []string
var imagesList [][]byte

// var global.FileLocal string
var tableUpperParts1 []produce.TableUpperPart

func createLogFile() {
	//	nowTime := time.Now()
	//	global.FileLocal = fmt.Sprintf("./file/OK_%s/images", nowTime.Format("2006-01-02 15:04:05.00000"))
	err := utils.CreateFolder(global.FileLocal)
	if err != nil {
		global.Logs.Error("创建结果images文件夹失败: ", err)
	} else {
		global.Logs.Printf("创建结果images文件夹成功: %s\n", global.FileLocal)
	}
	err = utils.CreateFolder(fmt.Sprintf(global.FileLocal + "/images/single"))
	if err != nil {
		global.Logs.Error("创建结果single文件夹失败: ", err)
	} else {
		global.Logs.Printf("创建结果single文件夹成功: %s\n", global.FileLocal)
	}
	err = utils.CreateFolder(fmt.Sprintf(global.FileLocal + "/images/merged"))
	if err != nil {
		global.Logs.Error("创建结果merged文件夹失败: ", err)
	} else {
		global.Logs.Printf("创建结果merged文件夹成功: %s\n", global.FileLocal)
	}
}

func AutoRun(config config.ConfigInfo) {
	//生成本次执行结果的文件夹
	createLogFile()
	//获取数据库连接
	db := dbBase.GetDb()
	//循环取出[sql]组下的片段，一个用例名称到下一个用列名称前为一个片段
	for _, Part := range config.CommandSql.Part {
		var tableUpperPartTemp produce.TableUpperPart
		tableUpperPartTemp.Left = make([]string, 0)
		tableUpperPartTemp.Right = make([]string, 0)
		tableUpperPartTemp.ImagesList = make([][]byte, 0)
		tableUpperPartTemp.SqlToTextsList = make([]string, 0)
		//文本
		var texts string
		//[].part 将片段转换为键值
		partMap := config.ParseGroupCase(Part)
		//将片段添加到tableUpperPartTemp
		tableUpperPartTemp.Left = append(tableUpperPartTemp.Left, "用例名称")
		tableUpperPartTemp.Right = append(tableUpperPartTemp.Right, partMap["用例名称"])
		tableUpperPartTemp.Left = append(tableUpperPartTemp.Left, "测试要求")
		tableUpperPartTemp.Right = append(tableUpperPartTemp.Right, partMap["测试要求"])
		tableUpperPartTemp.Left = append(tableUpperPartTemp.Left, "测试步骤")
		tableUpperPartTemp.Right = append(tableUpperPartTemp.Right, partMap["测试步骤"])
		tableUpperPartTemp.Left = append(tableUpperPartTemp.Left, "测试程序")
		tableUpperPartTemp.Right = append(tableUpperPartTemp.Right, partMap["测试程序"])

		//[].partMap[测试步骤]，sql运行
		global.Logs.Printf("测试步骤: %s\n", partMap["测试步骤"])
		partTestStepScanner := bufio.NewScanner(strings.NewReader(partMap["测试步骤"]))
		var sql string
		for partTestStepScanner.Scan() {
			partLine := strings.ToLower(strings.TrimSpace(partTestStepScanner.Text()))
			fmt.Printf("解析一行的sql partLine: %s\n", partLine)

			switch {
			//sql注释--
			case strings.HasPrefix(partLine, "--"):
				//fmt.Println("带有--key")
				sql = strings.TrimSpace(strings.TrimPrefix(partLine, "--"))
				texts += sql
				texts += "\n"
				texts += "\n"
				sql = ""

			//sql语句
			case strings.Contains(partLine, ";"):
				//fmt.Println("带有;key")
				fmt.Printf("是sql: %s\n", partLine)
				if strings.Contains(partLine, "<#") {
					texts += partLine
					texts += "\n"
					sql = ""
					sqlPart, files := fileInsert(db, partLine)
					retStr := dbBase.ExecFiles(db, sqlPart, files, partLine)

					var im produce.ImageInfo
					imageRet, err := im.Runimage(retStr)
					if err != nil {
						global.Logs.Error(err)
						return
					}
					imagesList = append(imagesList, imageRet)
					tableUpperPartTemp.ImagesList = append(tableUpperPartTemp.ImagesList, imageRet)
					now := time.Now()
					im.SaveImage(fmt.Sprintf("%s/(%s)_%s.png", fmt.Sprintf(global.FileLocal+"/images/single"), sqlPart[:15], now.Format("2006-01-02 15.04.05.00000")))

					break
				}

				if strings.Contains(partLine, "<%") {
					fmt.Println("带有<%key")
					texts += partLine
					texts += "\n"
					sql = ""
					sqlPart, files := fileInsert(db, partLine)
					retStr := dbBase.ExecClob(db, sqlPart, files, partLine)
					fmt.Println("CLOB：", retStr)

					var im produce.ImageInfo
					imageRet, err := im.Runimage(retStr)
					if err != nil {
						global.Logs.Error(err)
						return
					}
					imagesList = append(imagesList, imageRet)
					tableUpperPartTemp.ImagesList = append(tableUpperPartTemp.ImagesList, imageRet)
					now := time.Now()
					im.SaveImage(fmt.Sprintf("%s/(%s)_%s.png", fmt.Sprintf(global.FileLocal+"/images/single"), sqlPart[:15], now.Format("2006-01-02 15.04.05.00000")))

					break
				}

				if strings.Contains(partLine, "drop") {
					sql += strings.TrimSpace(partLine[:strings.Index(partLine, ";")+1])
					//fmt.Printf("sql TrimSpace: %s\n", sql)
					texts += sql
					texts += "\n"
					isQueryOrInsert(db, sql, &tableUpperPartTemp)
					sql = ""
					break
				}
				if strings.Contains(partLine, "procedure ") {
					endStr := "end;"
					sql += strings.TrimSpace(partLine[:strings.Index(partLine, endStr)+len(endStr)])
					fmt.Println("带有procedure key :", sql)
					texts += sql
					texts += "\n"
					isQueryOrInsert(db, sql, &tableUpperPartTemp)
					sql = ""
					break
				}

				sql += strings.TrimSpace(partLine[:strings.Index(partLine, ";")+1])
				//fmt.Printf("sql TrimSpace: %s\n", sql)
				texts += sql
				texts += "\n"
				isQueryOrInsert(db, sql, &tableUpperPartTemp)
				sql = ""
			default:
				//	fmt.Println("继续读取key")
				sql += strings.TrimSpace(partLine)
				texts += sql
				texts += "\n"
				sql += "\n"
			}
		}

		//将文本组添加到textsList
		//textsList = append(textsList, texts)
		tableUpperPartTemp.SqlToTextsList = append(tableUpperPartTemp.SqlToTextsList, texts)
		tableUpperParts1 = append(tableUpperParts1, tableUpperPartTemp)
		//检查[sql]下的片段读入是否错误
		if err := partTestStepScanner.Err(); err != nil {
			fmt.Println("partTestStepScanner.Error reading input:", err)
		}

		//删除当前用户的所有表
		// tableNames := dbBase.QueryUserTableName(db, "select table_name from user_tables ")
		// dbBase.ExecDorpTable(db, tableNames)
	}

	// for i := range tableUpperParts1 {
	// 	fmt.Printf("tableUpperParts1内有 %v 条数据\n", i+1)

	// }
	//生成word
	generateWord(tableUpperParts1)
}

func executeSQL(partLine string, db *sql.DB, tableUpperPartTemp *produce.TableUpperPart) {
	var texts string
	switch {
	//sql注释--
	case strings.HasPrefix(partLine, "--"):
		sql := strings.TrimSpace(strings.TrimPrefix(partLine, "--"))
		texts += sql
		texts += "\n"
		texts += "\n"
		//fmt.Printf("带有--key: %s\n", key)
	//sql语句
	case strings.Contains(partLine, ";"):
		//fmt.Printf("不带有--sql: %s\n", partLine)
		sql := strings.TrimSpace(partLine[:strings.Index(partLine, ";")+1])
		//fmt.Printf("sql TrimSpace: %s\n", sql)
		texts += sql
		texts += "\n"
		isQueryOrInsert(db, sql, tableUpperPartTemp)
	}
}

func isQueryOrInsert(db *sql.DB, sql string, tableUpperPartTemp *produce.TableUpperPart) {
	switch {
	//执行查询语句
	case strings.HasPrefix(sql, "select"):
		{

			ret := dbBase.QueryString(db, sql)

			var im produce.ImageInfo
			imageRet, err := im.Runimage(ret)
			if err != nil {
				global.Logs.Error(err)
				return
			}
			imagesList = append(imagesList, imageRet)
			tableUpperPartTemp.ImagesList = append(tableUpperPartTemp.ImagesList, imageRet)
			now := time.Now()
			im.SaveImage(fmt.Sprintf("%s/select %s_%s.png", fmt.Sprintf(global.FileLocal+"/images/single"), sql[len(sql)-5:], now.Format("2006-01-02 15.04.05.00000")))

		}
	//执行大对象插入语句
	// case strings.Contains(sql, "<#"):
	// 	{
	// 		fmt.Printf("\nsql is 大对象插入: %s\n", sql)
	// 		sqlPart, files := isBlob(db, sql)
	// 		fmt.Println("大对象：", sqlPart)
	// 		retStr := dbBase.ExecFiles(db, sqlPart, files)
	// 		fmt.Println("大对象：", retStr)
	// 		var im produce.ImageInfo
	// 		imageRet, err := im.Runimage(retStr)
	// 		if err != nil {
	// 			global.Logs.Error(err)
	// 			return
	// 		}
	// 		imagesList = append(imagesList, imageRet)
	// 		tableUpperPartTemp.ImagesList = append(tableUpperPartTemp.ImagesList, imageRet)
	// 		now := time.Now()
	// 		im.SaveImage(fmt.Sprintf("%s/(%s)_%s.png", fmt.Sprintf(global.FileLocal+"/images/single"), sql[:15], now.Format("2006-01-02 15.04.05.00000")))
	// 	}
	//其他语句调用exec函数
	default:
		{
			//不是大对象插入语句的处理
			//fmt.Printf("\nsql is 不是大对象插入语句的处理: %s\n", sql)
			if strings.Contains(sql, "set session") {
				fmt.Println("执行set session")
			}
			ret := dbBase.ExecString(db, sql)
			var im produce.ImageInfo
			imageRet, err := im.Runimage(ret)
			if err != nil {
				global.Logs.Error(err)
				return
			}
			imagesList = append(imagesList, imageRet)
			tableUpperPartTemp.ImagesList = append(tableUpperPartTemp.ImagesList, imageRet)
			now := time.Now()
			if len(sql) < 15 {
				im.SaveImage(fmt.Sprintf("%s/(%s)_%s.png", fmt.Sprintf(global.FileLocal+"/images/single"), sql[5:], now.Format("2006-01-02 15.04.05.00000")))
				break
			}
			im.SaveImage(fmt.Sprintf("%s/(%s)_%s.png", fmt.Sprintf(global.FileLocal+"/images/single"), sql[:15], now.Format("2006-01-02 15.04.05.00000")))
		}
	}
}

// 是否是大对象语句
func fileInsert(db *sql.DB, sql string) (string, []string) {
	questionMarksCount := utils.IsInsertBlob(sql)
	fmt.Println("questionMarksCount", questionMarksCount)
	sqlPart, filePart, err := splitBlobAndClobString(sql)
	if err != nil {
		global.Logs.Error("切分Blob语句错误", err)
		return "", nil
	}
	fmt.Printf("part1: %s\n", sqlPart)
	fmt.Printf("part2: %s\n", filePart)
	files := deleteSymbol(filePart)
	fmt.Println("isBlob")
	return sqlPart, files
}

func splitBlobAndClobString(input string) (string, string, error) {
	fmt.Println("splitBlobString: ", input)
	splitIndex := strings.Index(input, "<#")
	if splitIndex == -1 {
		splitIndex = strings.Index(input, "<%")
		if splitIndex == -1 {
			return "", "", fmt.Errorf("delimiter '<#' not found in the input string")
		}
	}

	part1 := strings.TrimSpace(input[:splitIndex])
	part2 := strings.TrimSpace(input[splitIndex:]) // +2 to exclude '<#'

	return part1, part2, nil
}

func deleteSymbol(input string) []string {
	// 去掉 <# 符号
	cleanedInput := strings.ReplaceAll(input, "<#", "")
	fmt.Println("cleanedInput: ", cleanedInput)
	cleanedInput2 := strings.ReplaceAll(cleanedInput, "<%", "")
	fmt.Println("cleanedInput2: ", cleanedInput2)
	// 按空格切割
	parts := strings.Fields(cleanedInput2)

	// 打印结果
	for _, part := range parts {
		fmt.Println(part)
	}
	return parts
}

// 生成word
func generateWord(tableUpperParts1 []produce.TableUpperPart) {
	fmt.Println("调用generateWord()")
	wd := produce.Newword()
	for _, tableUpperPart := range tableUpperParts1 {

		//fmt.Printf("text: %v\n", text)
		//fmt.Println("tableUpperPart.ImagesList: ", tableUpperPart.ImagesList)
		if tableUpperPart.ImagesList == nil || len(tableUpperPart.ImagesList) == 0 {

			global.Logs.Error("图片缓存为空,退出程序")
			return
		}
		mergedImage, err := produce.MergeImages(tableUpperPart.ImagesList)
		if err != nil {
			panic(err)
		}

		wd.WriterTable(global.FileLocal, tableUpperPart, mergedImage)

		//保存图片
		timeNow := time.Now().Format("2006-01-02 15.04.05.00000")
		// 生成随机整数
		randomInt := rand.Intn(100) // 生成0到99之间的随机整数
		err = os.WriteFile(fmt.Sprintf("%s/merged_image_%s_%d.png", fmt.Sprintf(global.FileLocal+"/images/merged"), timeNow, randomInt), mergedImage, 0644)
		if err != nil {
			panic(err)
		}
		fmt.Println("生成合成图片-------------")
		//imagesList = nil
	}
	//保存word为文件
	wd.SaveWord(global.FileLocal)
}