gitee.com/KyleChenSource/lib-robot@v1.0.2/robottest/protos/protos_test.go (about)

     1  package protos
     2  
     3  import (
     4  	"flag"
     5  	"fmt"
     6  	"os"
     7  	"testing"
     8  
     9  	"gitee.com/KyleChenSource/lib-robot/robottest/log"
    10  
    11  	"gitee.com/KyleChenSource/lib-robot/robottest/common/interpreter"
    12  
    13  	"github.com/valyala/fastjson"
    14  )
    15  
    16  var (
    17  	cwd = flag.String("cwd", "", "set cwd")
    18  )
    19  
    20  func init() {
    21  	_ = log.LogInitialize("logic_test.log", 0)
    22  	interpreter.LogDebug = log.LogDebug
    23  	interpreter.LogDebug = log.LogInfo
    24  	interpreter.LogDebug = log.LogError
    25  }
    26  
    27  func ChDir(path string) (string, error) {
    28  	if path == "" {
    29  		return "", fmt.Errorf("path nil")
    30  	}
    31  
    32  	dir, err := os.Getwd()
    33  	if err != nil {
    34  		log.LogError("os.Getwd err:%s", err.Error())
    35  		return dir, err
    36  	}
    37  
    38  	if dir != path {
    39  		if err := os.Chdir(path); err != nil {
    40  			log.LogError("Change CWD:%s failed. now CWD:%s", path, dir)
    41  			return dir, err
    42  		}
    43  
    44  		newdir, _ := os.Getwd()
    45  		log.LogInfo("Change CWD:%s to:%s", dir, newdir)
    46  		return dir, err
    47  	}
    48  
    49  	log.LogInfo("Change CWD:%s to:%s", dir, dir)
    50  	return dir, err
    51  }
    52  
    53  func TestJsonProtoLogic(t *testing.T) {
    54  	f, err := os.ReadFile("logictest.json")
    55  	if err != nil {
    56  		t.Errorf("ReadFile err:%s", err.Error())
    57  		return
    58  	}
    59  
    60  	j, err := fastjson.ParseBytes(f)
    61  	if err != nil {
    62  		t.Errorf("ParseBytes err:%s", err.Error())
    63  		return
    64  	}
    65  
    66  	tests := j.GetArray("tests")
    67  	for _, td := range tests {
    68  		data := td.Get("data").String()
    69  		// data -> pb
    70  		// pb := &proto_csmsg.UnitBuffList{}
    71  		// err = protojson.Unmarshal([]byte(data), pb)
    72  		// if err != nil {
    73  		// 	t.Errorf("Unmarshal:%s", err.Error())
    74  		// 	return
    75  		// }
    76  		// log.LogInfo(fmt.Sprintf("protobuf:%v", pb))
    77  		// do, err := protojson.Marshal(pb)
    78  		// if err != nil {
    79  		// 	t.Errorf("Unmarshal:%s", err.Error())
    80  		// 	return
    81  		// }
    82  		// log.LogInfo("bytes:%s", string(do))
    83  
    84  		checks := make(map[string]CheckData)
    85  
    86  		cs := td.GetObject("checks")
    87  		cs.Visit(func(k []byte, v *fastjson.Value) {
    88  			checks[string(k)] = CheckData{
    89  				Check:        string(v.GetStringBytes("check")),
    90  				Failcontinue: v.GetBool("failcontinue"),
    91  			}
    92  		})
    93  
    94  		r, c, err := JsonCheck(data, checks, nil)
    95  		if err != nil {
    96  			t.Errorf("err:%s", err.Error())
    97  			return
    98  		}
    99  
   100  		log.LogInfo("%s checks:%v r:%T c:%T\n", data, checks, r, c)
   101  	}
   102  }
   103  
   104  func TestProtos(t *testing.T) {
   105  	old, _ := ChDir(*cwd)
   106  	defer func() {
   107  		ChDir(old)
   108  	}()
   109  
   110  	p, err := NetworkProtoData("test1.json", "login")
   111  	if err != nil {
   112  		t.Error(err.Error())
   113  		return
   114  	}
   115  
   116  	log.LogInfo("%v\n", p)
   117  }
   118  
   119  type TestCtxImp struct {
   120  	_ctx map[string]any
   121  }
   122  
   123  func (this *TestCtxImp) Get(s string) (any, bool) {
   124  	ret, err := this._ctx[s]
   125  	return ret, err
   126  }
   127  
   128  func (this *TestCtxImp) Set(s string, v any) {
   129  	this._ctx[s] = v
   130  }
   131  
   132  func TestRegexReplace(t *testing.T) {
   133  	old, _ := ChDir(*cwd)
   134  	defer func() {
   135  		ChDir(old)
   136  	}()
   137  
   138  	p, err := NetworkProtoData("replace_test.json", "login")
   139  	if err != nil {
   140  		t.Error(err.Error())
   141  		return
   142  	}
   143  
   144  	data := TestCtxImp{}
   145  	data._ctx = make(map[string]any)
   146  
   147  	data.Set("account", "okkkkk")
   148  
   149  	r, err := JsonReplace(p.Data, &data)
   150  	if err != nil {
   151  		t.Error(err.Error())
   152  		return
   153  	}
   154  
   155  	log.LogInfo("%s to %s", p.Data, r)
   156  }
   157  
   158  func TestProtoLoadSave(t *testing.T) {
   159  	old, _ := ChDir("../../bin/")
   160  	defer func() {
   161  		ChDir(old)
   162  	}()
   163  	err := FileLoad("test1.json")
   164  	if err != nil {
   165  		t.Errorf("Load err:%s", err.Error())
   166  	}
   167  
   168  	err = FileSave("test1.json")
   169  	if err != nil {
   170  		t.Errorf("FileSave err:%s", err.Error())
   171  	}
   172  }