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.
899 lines
26 KiB
899 lines
26 KiB
package service |
|
|
|
/** |
|
* 需要缓存的对象 |
|
****************************************** |
|
* one2many |
|
* key type val |
|
* flow int64+avail []*tokenbind,err---ok |
|
* flow int64+dir []*dir,err |
|
* netid int64 []*flow,err --- ok |
|
* netid []int64,avail,disp []int64,err--transitionid |
|
* tranid []int64,isbatch []*tokenbind,err---ok |
|
* tranid int64,avail []*dir.err |
|
* biz int64 []int64,err---netid ---ok |
|
* |
|
* one2one |
|
* ids []int64,xxx,yy []*struct,err --- net/bind/flow/=ok |
|
****************************************** |
|
* testing: |
|
* 1. get objs by ids |
|
* 2. get objs by obj.aggregate_field |
|
* 3. get obj ids by obj.aggregate_field |
|
*/ |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"fmt" |
|
"reflect" |
|
"strings" |
|
"testing" |
|
|
|
"github.com/smartystreets/goconvey/convey" |
|
"go-common/app/admin/main/aegis/model/net" |
|
"go-common/library/database/orm" |
|
) |
|
|
|
var ( |
|
testaggrmap = map[int64]struct { |
|
Rela []int64 |
|
JSON string |
|
}{ |
|
1: {Rela: []int64{1, 2}, JSON: "1,2"}, |
|
2: {Rela: []int64{3, 4}, JSON: "3,4"}, |
|
} |
|
testaggrv = []int64{1, 2} |
|
testaggrcache = map[string]string{ |
|
"test_aggr:1": "1,2", |
|
"test_aggr:2": "3,4", |
|
} |
|
testaggrdest = &AggrCacheDest{ |
|
GetKey: func(id int64, opt ...interface{}) (k []string) { |
|
k = []string{fmt.Sprintf("test_aggr:%d", id)} |
|
return |
|
}, |
|
AggrRelaRaw: func(c context.Context, miss []int64, kopt []interface{}, opt ...interface{}) (rela map[int64][]int64, err error) { |
|
rela = map[int64][]int64{} |
|
for _, i := range miss { |
|
rela[i] = testaggrmap[i].Rela |
|
} |
|
return |
|
}, |
|
} |
|
|
|
testflows = []*net.Flow{ |
|
{ID: 50, Name: "init", NetID: 99}, |
|
{ID: 51, Name: "first", NetID: 99}, |
|
{ID: 52, Name: "init", NetID: 100}, |
|
} |
|
testnets = []*net.Net{ |
|
{ID: 8, ChName: "测试网1", BusinessID: 10}, |
|
{ID: 9, ChName: "测试网1", BusinessID: 10}, |
|
{ID: 10, ChName: "测试网1", BusinessID: 11}, |
|
} |
|
testtokens = []*net.Token{ |
|
{ID: 50, NetID: 10, Name: "test1", Compare: 0, Value: "0"}, |
|
{ID: 51, NetID: 10, Name: "test2", Compare: 0, Value: "0"}, |
|
{ID: 52, NetID: 11, Name: "test2", Compare: 0, Value: "0"}, |
|
} |
|
testbinds = []*net.TokenBind{ |
|
{ID: 50, Type: 1, ElementID: 10, TokenID: "8"}, |
|
{ID: 51, Type: 1, ElementID: 10, TokenID: "9"}, |
|
{ID: 52, Type: 2, ElementID: 11, TokenID: "8"}, |
|
} |
|
testtrans = []*net.Transition{ |
|
{ID: 50, NetID: 10, Trigger: 1, Limit: 1, Name: "test1"}, |
|
{ID: 51, NetID: 10, Trigger: 1, Limit: 1, Name: "test2"}, |
|
{ID: 52, NetID: 11, Trigger: 1, Limit: 1, Name: "test3"}, |
|
} |
|
testdirs = []*net.Direction{ |
|
{ID: 50, NetID: 10, FlowID: 10, TransitionID: 20, Direction: 1}, |
|
{ID: 51, NetID: 10, FlowID: 11, TransitionID: 20, Direction: 2}, |
|
{ID: 52, NetID: 10, FlowID: 11, TransitionID: 21, Direction: 1}, |
|
{ID: 53, NetID: 10, FlowID: 12, TransitionID: 21, Direction: 2}, |
|
} |
|
testdata = map[string]struct { |
|
RowObj interface{} |
|
RowObjLen int |
|
RowRela map[int64][]int64 |
|
Caches map[string]string |
|
AggrID, ObjID []int64 |
|
}{ |
|
"flow": { |
|
RowObj: testflows, |
|
RowObjLen: 3, |
|
RowRela: map[int64][]int64{99: {50, 51}, 100: {52}}, |
|
Caches: map[string]string{ |
|
"net_flow:99": "50,51", |
|
"net_flow:100": "52", |
|
"flow:50": getjsonobj(testflows[0]), |
|
"flow:51": getjsonobj(testflows[1]), |
|
"flow:52": getjsonobj(testflows[2]), |
|
}, |
|
AggrID: []int64{99, 100, 101}, |
|
ObjID: []int64{50, 51, 52}, |
|
}, |
|
"net": { |
|
RowObj: testnets, |
|
RowObjLen: 3, |
|
RowRela: map[int64][]int64{10: {8, 9}, 11: {10}}, |
|
Caches: map[string]string{ |
|
"business_net:10": "8,9", |
|
"business_net:11": "10", |
|
"net:8": getjsonobj(testnets[0]), |
|
"net:9": getjsonobj(testnets[1]), |
|
"net:10": getjsonobj(testnets[2]), |
|
}, |
|
AggrID: []int64{10, 11, 1200}, |
|
ObjID: []int64{8, 9, 10}, |
|
}, |
|
"token": { |
|
RowObj: testtokens, |
|
RowObjLen: 3, |
|
Caches: map[string]string{ |
|
"token:50": getjsonobj(testtokens[0]), |
|
"token:51": getjsonobj(testtokens[1]), |
|
"token:52": getjsonobj(testtokens[2]), |
|
}, |
|
ObjID: []int64{50, 51, 52}, |
|
}, |
|
"bind": { |
|
RowObj: testbinds, |
|
RowObjLen: 3, |
|
RowRela: map[int64][]int64{10: {50, 51}, 11: {52}}, |
|
Caches: map[string]string{ |
|
"flow_bind:10": "50,51", |
|
"transition_bind:11": "52", |
|
"bind:50": getjsonobj(testbinds[0]), |
|
"bind:51": getjsonobj(testbinds[1]), |
|
"bind:52": getjsonobj(testbinds[2]), |
|
}, |
|
AggrID: []int64{10, 11, 1200}, |
|
ObjID: []int64{50, 51, 52}, |
|
}, |
|
"tran": { |
|
RowObj: testtrans, |
|
RowObjLen: 3, |
|
RowRela: map[int64][]int64{10: {50, 51}, 11: {52}}, |
|
Caches: map[string]string{ |
|
"net_transition:10": "50,51", |
|
"net_transition:11": "52", |
|
"transition:50": getjsonobj(testtrans[0]), |
|
"transition:51": getjsonobj(testtrans[1]), |
|
"transition:52": getjsonobj(testtrans[2]), |
|
}, |
|
AggrID: []int64{10, 11, 12000}, |
|
ObjID: []int64{50, 51, 52}, |
|
}, |
|
} |
|
testdata2 = map[string]struct { |
|
RowObj interface{} |
|
RowObjLen int |
|
RowRela map[int64]map[int8][]int64 |
|
Caches map[string]string |
|
ObjID []int64 |
|
AggrID []int64 |
|
}{ |
|
"dir": { |
|
RowObj: testdirs, |
|
RowObjLen: 4, |
|
RowRela: map[int64]map[int8][]int64{ |
|
10: {1: {50}}, |
|
11: {1: {52}, 2: {51}}, |
|
12: {2: {53}}, |
|
20: {1: {50}, 2: {51}}, |
|
21: {1: {52}, 2: {53}}, |
|
}, |
|
Caches: map[string]string{ |
|
"flow_direction_1:10": "50", |
|
"flow_direction_1:11": "52", |
|
"flow_direction_2:11": "51", |
|
"flow_direction_2:12": "53", |
|
"transition_direction_1:20": "50", |
|
"transition_direction_2:20": "51", |
|
"transition_direction_1:21": "52", |
|
"transition_direction_2:21": "53", |
|
"direction:50": getjsonobj(testdirs[0]), |
|
"direction:51": getjsonobj(testdirs[1]), |
|
"direction:52": getjsonobj(testdirs[2]), |
|
"direction:53": getjsonobj(testdirs[3]), |
|
}, |
|
AggrID: []int64{10, 11, 12, 20, 21, 12000}, |
|
ObjID: []int64{50, 51, 52, 53}, |
|
}, |
|
} |
|
|
|
getjsonobj = func(v interface{}) string { |
|
bs, _ := json.Marshal(v) |
|
return string(bs) |
|
} |
|
) |
|
|
|
func TestServiceAppendString(t *testing.T) { |
|
convey.Convey("AppendString", t, func(ctx convey.C) { |
|
testaggrdest.Dest = map[int64][]int64{} |
|
ctx.Convey("err=nil, ok=true, aggrdest expected", func(ctx convey.C) { |
|
for id, item := range testaggrmap { |
|
ok, err := testaggrdest.AppendString(id, item.JSON) |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(ok, convey.ShouldEqual, true) |
|
ctx.So(fmt.Sprintf("%v", testaggrdest.Dest[id]), convey.ShouldEqual, fmt.Sprintf("%v", item.Rela)) |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestServiceAppendRelationRaw(t *testing.T) { |
|
convey.Convey("AppendRelationRaw", t, func(ctx convey.C) { |
|
missCache, err := testaggrdest.AppendRelationRaw(cntx, testaggrv, nil) |
|
ctx.Convey("Then err should be nil.missCache should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(missCache, convey.ShouldNotBeNil) |
|
for k, v := range missCache { |
|
ctx.So(v, convey.ShouldEqual, testaggrcache[k]) |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func testdataprepare(k string, v interface{}) { |
|
testdao := orm.NewMySQL(s.c.ORM) |
|
objs := reflect.ValueOf(v) |
|
for i := 0; i < objs.Len(); i++ { |
|
testdao.Save(objs.Index(i).Interface()) |
|
} |
|
} |
|
|
|
func TestServiceAppendAggregateRaw(t *testing.T) { |
|
convey.Convey("AppendAggregateRaw", t, func(ctx convey.C) { |
|
objdest := &flowArr{} |
|
w := &CacheWrap{ |
|
ObjDest: objdest, |
|
AggrObjRaw: s.netFlowAppendRaw, |
|
AggregateDest: &AggrCacheDest{ |
|
GetKey: s.netFlowKey, |
|
AggrRelaRaw: s.netFlowRelation, |
|
}, |
|
} |
|
|
|
k := "flow" |
|
testdataprepare(k, testdata[k].RowObj) |
|
missCache, err := w.AppendAggregateRaw(cntx, testdata[k].AggrID, nil) |
|
ctx.Convey("Then err should be nil.missCache should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(missCache, convey.ShouldNotBeNil) |
|
//对象存在 & 聚合关系存在 & 待缓存值存在 |
|
ctx.So(len(objdest.dest), convey.ShouldEqual, testdata[k].RowObjLen) |
|
for ck, v := range testdata[k].RowRela { |
|
ctx.So(fmt.Sprintf("%v", w.AggregateDest.Dest[ck]), convey.ShouldEqual, fmt.Sprintf("%v", v)) |
|
} |
|
for ck, v := range testdata[k].Caches { |
|
pos := strings.Index(missCache[ck], "ctime") //json化的 |
|
if pos == -1 { |
|
ctx.So(missCache[ck], convey.ShouldEqual, v) |
|
} else { |
|
ctx.So(missCache[ck][:pos], convey.ShouldEqual, v[:pos]) |
|
} |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestServiceGetFromCache(t *testing.T) { |
|
convey.Convey("getFromCache", t, func(ctx convey.C) { |
|
k := "flow" |
|
//delete cache |
|
keypro := s.netFlowKey |
|
llen := len(testdata[k].AggrID) + 2 |
|
keys := []string{} |
|
ids := append(testdata[k].AggrID, 1000, 2000) |
|
for _, id := range ids { |
|
keys = append(keys, keypro(id)...) |
|
} |
|
s.redis.DelMulti(cntx, keys...) |
|
//miss all |
|
miss := s.getFromCache(cntx, ids, keypro, &flowArr{}, nil) |
|
|
|
//set last 2 caches & get from cache |
|
s.redis.SetMulti(cntx, map[string]string{keys[llen-1]: "10000", keys[llen-2]: "20000"}) |
|
miss2 := s.getFromCache(cntx, ids, keypro, &AggrCacheDest{}, nil) |
|
|
|
ctx.Convey("Then miss should not be nil.", func(ctx convey.C) { |
|
ctx.So(miss, convey.ShouldNotBeNil) |
|
ctx.So(fmt.Sprintf("%v", miss), convey.ShouldEqual, fmt.Sprintf("%v", ids)) |
|
ctx.So(fmt.Sprintf("%v", miss2), convey.ShouldEqual, fmt.Sprintf("%v", testdata[k].AggrID)) |
|
}) |
|
}) |
|
} |
|
|
|
func TestServiceobjCache(t *testing.T) { |
|
convey.Convey("objCache", t, func(ctx convey.C) { |
|
k := "flow" |
|
ids := testdata[k].ObjID |
|
objdest := &flowArr{} |
|
err := s.objCache(cntx, ids, objdest, nil) |
|
objm := map[int64]*net.Flow{} |
|
for _, item := range objdest.dest { |
|
objm[item.ID] = item |
|
} |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
for _, id := range ids { |
|
ctx.So(objm[id], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestServiceaggregateRelationCache(t *testing.T) { |
|
convey.Convey("aggregateRelationCache", t, func(ctx convey.C) { |
|
k := "flow" |
|
aggrdest := &AggrCacheDest{ |
|
GetKey: s.netFlowKey, |
|
AggrRelaRaw: s.netFlowRelation, |
|
} |
|
err := s.aggregateRelationCache(cntx, testdata[k].AggrID, aggrdest, nil) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
for nid, v := range testdata[k].RowRela { |
|
ctx.So(len(aggrdest.Dest[nid]), convey.ShouldEqual, len(v)) |
|
mmp := map[int64]int64{} |
|
for _, i := range v { |
|
mmp[i] = i |
|
} |
|
for _, i := range aggrdest.Dest[nid] { |
|
ctx.So(i, convey.ShouldEqual, mmp[i]) |
|
} |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestServiceaggregateCache(t *testing.T) { |
|
convey.Convey("aggregateCache", t, func(ctx convey.C) { |
|
k := "flow" |
|
objdest := &flowArr{} |
|
w := &CacheWrap{ |
|
ObjDest: objdest, |
|
AggrObjRaw: s.netFlowAppendRaw, |
|
AggregateDest: &AggrCacheDest{ |
|
GetKey: s.netFlowKey, |
|
}, |
|
} |
|
err := s.aggregateCache(cntx, testdata[k].AggrID, w, nil, nil, nil, nil) |
|
objm := map[int64]*net.Flow{} |
|
for _, item := range objdest.dest { |
|
objm[item.ID] = item |
|
} |
|
|
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
for id, v := range testdata[k].RowRela { |
|
ctx.So(len(w.AggregateDest.Dest[id]), convey.ShouldEqual, len(v)) |
|
mmp := map[int64]int64{} |
|
for _, i := range v { |
|
mmp[i] = i |
|
} |
|
for _, i := range w.AggregateDest.Dest[id] { |
|
ctx.So(i, convey.ShouldEqual, mmp[i]) |
|
} |
|
} |
|
for _, id := range testdata[k].ObjID { |
|
ctx.So(objm[id], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestServicedelCache(t *testing.T) { |
|
convey.Convey("delCache", t, func(ctx convey.C) { |
|
err := s.delCache(cntx, []string{}) |
|
ctx.Convey("Then err should be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
}) |
|
}) |
|
} |
|
|
|
func TestNetArrGetKey(t *testing.T) { |
|
convey.Convey("netArrGetKey", t, func(ctx convey.C) { |
|
objdest := &netArr{} |
|
p1 := objdest.GetKey(0) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
} |
|
|
|
func TestNetArrAppendString(t *testing.T) { |
|
convey.Convey("netArrAppendString", t, func(ctx convey.C) { |
|
objdest := &netArr{} |
|
k := "net" |
|
testdataprepare(k, testdata[k].RowObj) |
|
v := testdata[k].Caches[objdest.GetKey(testdata[k].ObjID[0])[0]] |
|
ok, err := objdest.AppendString(testdata[k].ObjID[0], v) |
|
ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(ok, convey.ShouldEqual, true) |
|
ctx.So(objdest.dest[0].ID, convey.ShouldEqual, testdata[k].ObjID[0]) |
|
}) |
|
}) |
|
} |
|
|
|
func TestNetArrAppendRaw(t *testing.T) { |
|
convey.Convey("netArrAppendRaw", t, func(ctx convey.C) { |
|
objdest := &netArr{} |
|
k := "net" |
|
missCache, err := objdest.AppendRaw(cntx, s, testdata[k].ObjID, nil) |
|
objm := map[int64]*net.Net{} |
|
for _, item := range objdest.dest { |
|
objm[item.ID] = item |
|
} |
|
ctx.Convey("Then err should be nil.missCache should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
for ck, v := range testdata[k].Caches { |
|
if strings.Contains(ck, "business_net") { |
|
continue |
|
} |
|
pos := strings.Index(v, "ctime") |
|
if pos == -1 { |
|
ctx.So(fmt.Sprintf("%v", missCache[ck]), convey.ShouldEqual, fmt.Sprintf("%v", v)) |
|
} else { |
|
ctx.So(fmt.Sprintf("%v", missCache[ck][:pos]), convey.ShouldEqual, fmt.Sprintf("%v", v[:pos])) |
|
} |
|
} |
|
for _, id := range testdata[k].ObjID { |
|
ctx.So(objm[id], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestNetCache(t *testing.T) { |
|
convey.Convey("NetCache", t, func(ctx convey.C) { |
|
k := "net" |
|
biz := testdata[k].AggrID[0] |
|
res, err := s.netIDByBusiness(cntx, biz) |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(fmt.Sprintf("%v", res), convey.ShouldEqual, fmt.Sprintf("%v", testdata[k].RowRela[biz])) |
|
|
|
id := testdata[k].ObjID[0] |
|
res2, err := s.netByID(cntx, id) |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(res2.ID, convey.ShouldEqual, id) |
|
|
|
err = s.delNetCache(cntx, res2) |
|
ctx.So(err, convey.ShouldBeNil) |
|
|
|
res3, err := s.netIDByBusiness(cntx, biz) |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(fmt.Sprintf("%v", res3), convey.ShouldEqual, fmt.Sprintf("%v", testdata[k].RowRela[biz])) |
|
|
|
res4, err := s.netByID(cntx, id) |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(res4.ID, convey.ShouldEqual, id) |
|
}) |
|
} |
|
|
|
func TestTokenArrGetKey(t *testing.T) { |
|
convey.Convey("TokenArrGetKey", t, func(ctx convey.C) { |
|
objdest := &tokenArr{} |
|
p1 := objdest.GetKey(0) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
} |
|
|
|
func TestTokenArrAppendString(t *testing.T) { |
|
convey.Convey("TokenArrAppendString", t, func(ctx convey.C) { |
|
objdest := &tokenArr{} |
|
k := "token" |
|
testdataprepare(k, testdata[k].RowObj) |
|
v := testdata[k].Caches[objdest.GetKey(testdata[k].ObjID[0])[0]] |
|
ok, err := objdest.AppendString(testdata[k].ObjID[0], v) |
|
ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(ok, convey.ShouldEqual, true) |
|
ctx.So(objdest.dest[0].ID, convey.ShouldEqual, testdata[k].ObjID[0]) |
|
}) |
|
}) |
|
} |
|
|
|
func TestTokenArrAppendRaw(t *testing.T) { |
|
convey.Convey("TokenArrAppendRaw", t, func(ctx convey.C) { |
|
objdest := &tokenArr{} |
|
k := "token" |
|
missCache, err := objdest.AppendRaw(cntx, s, testdata[k].ObjID, nil) |
|
objm := map[int64]*net.Token{} |
|
for _, item := range objdest.dest { |
|
objm[item.ID] = item |
|
} |
|
ctx.Convey("Then err should be nil.missCache should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
for ck, v := range testdata[k].Caches { |
|
pos := strings.Index(v, "ctime") |
|
if pos == -1 { |
|
ctx.So(fmt.Sprintf("%v", missCache[ck]), convey.ShouldEqual, fmt.Sprintf("%v", v)) |
|
} else { |
|
ctx.So(fmt.Sprintf("%v", missCache[ck][:pos]), convey.ShouldEqual, fmt.Sprintf("%v", v[:pos])) |
|
} |
|
} |
|
for _, id := range testdata[k].ObjID { |
|
ctx.So(objm[id], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestTokenCache(t *testing.T) { |
|
convey.Convey("TokenCache", t, func(ctx convey.C) { |
|
k := "token" |
|
biz := testdata[k].ObjID |
|
res, err := s.tokens(cntx, biz) |
|
ctx.So(err, convey.ShouldBeNil) |
|
resm := map[int64]*net.Token{} |
|
for _, item := range res { |
|
resm[item.ID] = item |
|
} |
|
for _, i := range biz { |
|
ctx.So(resm[i], convey.ShouldNotBeNil) |
|
} |
|
|
|
keys := []string{} |
|
for ck := range testdata[k].Caches { |
|
keys = append(keys, ck) |
|
} |
|
err = s.redis.DelMulti(cntx, keys...) |
|
ctx.So(err, convey.ShouldBeNil) |
|
|
|
res2, err := s.tokens(cntx, biz) |
|
ctx.So(err, convey.ShouldBeNil) |
|
resm2 := map[int64]*net.Token{} |
|
for _, item := range res2 { |
|
resm2[item.ID] = item |
|
} |
|
for _, i := range biz { |
|
ctx.So(resm2[i], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
} |
|
|
|
func TestBindArrGetKey(t *testing.T) { |
|
convey.Convey("BindArrGetKey", t, func(ctx convey.C) { |
|
objdest := &bindArr{} |
|
p1 := objdest.GetKey(0) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
} |
|
|
|
func TestBindArrAppendString(t *testing.T) { |
|
convey.Convey("BindArrAppendString", t, func(ctx convey.C) { |
|
objdest := &bindArr{} |
|
k := "bind" |
|
testdataprepare(k, testdata[k].RowObj) |
|
v := testdata[k].Caches[objdest.GetKey(testdata[k].ObjID[0])[0]] |
|
ok, err := objdest.AppendString(testdata[k].ObjID[0], v) |
|
ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(ok, convey.ShouldEqual, true) |
|
ctx.So(objdest.dest[0].ID, convey.ShouldEqual, testdata[k].ObjID[0]) |
|
}) |
|
}) |
|
} |
|
|
|
func TestBindArrAppendRaw(t *testing.T) { |
|
convey.Convey("BindArrAppendRaw", t, func(ctx convey.C) { |
|
objdest := &bindArr{} |
|
k := "bind" |
|
missCache, err := objdest.AppendRaw(cntx, s, testdata[k].ObjID, nil) |
|
objm := map[int64]*net.TokenBind{} |
|
for _, item := range objdest.dest { |
|
objm[item.ID] = item |
|
} |
|
ctx.Convey("Then err should be nil.missCache should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
for ck, v := range testdata[k].Caches { |
|
if strings.Contains(ck, "flow_bind") || strings.Contains(ck, "transition_bind") { |
|
continue |
|
} |
|
pos := strings.Index(v, "ctime") |
|
if pos == -1 { |
|
ctx.So(fmt.Sprintf("%v", missCache[ck]), convey.ShouldEqual, fmt.Sprintf("%v", v)) |
|
} else { |
|
ctx.So(fmt.Sprintf("%v", missCache[ck][:pos]), convey.ShouldEqual, fmt.Sprintf("%v", v[:pos])) |
|
} |
|
} |
|
for _, id := range testdata[k].ObjID { |
|
ctx.So(objm[id], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestBindCache(t *testing.T) { |
|
convey.Convey("BindCache", t, func(ctx convey.C) { |
|
k := "bind" |
|
biz := testdata[k].AggrID |
|
res, err := s.tokenBindByElement(cntx, biz, []int8{net.BindTypeFlow}) |
|
resm := map[int64]*net.TokenBind{} |
|
for _, item := range res { |
|
t.Logf("flow bind tokens in biz(%+v) item(%+v)", biz, item) |
|
resm[item.ID] = item |
|
} |
|
ctx.So(err, convey.ShouldBeNil) |
|
for _, i := range testdata[k].ObjID[:2] { |
|
ctx.So(resm[i], convey.ShouldNotBeNil) |
|
} |
|
|
|
res, err = s.tokenBindByElement(cntx, biz, net.BindTranType) |
|
for _, item := range res { |
|
resm[item.ID] = item |
|
} |
|
ctx.So(err, convey.ShouldBeNil) |
|
|
|
res2, err := s.tokenBinds(cntx, testdata[k].ObjID, true) |
|
resm2 := map[int64]*net.TokenBind{} |
|
for _, item := range res2 { |
|
resm2[item.ID] = item |
|
} |
|
ctx.So(err, convey.ShouldBeNil) |
|
for _, i := range testdata[k].ObjID { |
|
ctx.So(resm2[i], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
} |
|
|
|
func TestFlowArrGetKey(t *testing.T) { |
|
convey.Convey("FlowArrGetKey", t, func(ctx convey.C) { |
|
objdest := &flowArr{} |
|
p1 := objdest.GetKey(0) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
} |
|
|
|
func TestFlowArrAppendString(t *testing.T) { |
|
convey.Convey("FlowArrAppendString", t, func(ctx convey.C) { |
|
objdest := &flowArr{} |
|
k := "flow" |
|
testdataprepare(k, testdata[k].RowObj) |
|
v := testdata[k].Caches[objdest.GetKey(testdata[k].ObjID[0])[0]] |
|
ok, err := objdest.AppendString(testdata[k].ObjID[0], v) |
|
ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(ok, convey.ShouldEqual, true) |
|
ctx.So(objdest.dest[0].ID, convey.ShouldEqual, testdata[k].ObjID[0]) |
|
}) |
|
}) |
|
} |
|
|
|
func TestFlowArrAppendRaw(t *testing.T) { |
|
convey.Convey("FlowArrAppendRaw", t, func(ctx convey.C) { |
|
objdest := &flowArr{} |
|
k := "flow" |
|
missCache, err := objdest.AppendRaw(cntx, s, testdata[k].ObjID, nil) |
|
objm := map[int64]*net.Flow{} |
|
for _, item := range objdest.dest { |
|
objm[item.ID] = item |
|
} |
|
ctx.Convey("Then err should be nil.missCache should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
for ck, v := range testdata[k].Caches { |
|
if strings.Contains(ck, "net_flow") { |
|
continue |
|
} |
|
pos := strings.Index(v, "ctime") |
|
if pos == -1 { |
|
ctx.So(fmt.Sprintf("%v", missCache[ck]), convey.ShouldEqual, fmt.Sprintf("%v", v)) |
|
} else { |
|
ctx.So(fmt.Sprintf("%v", missCache[ck][:pos]), convey.ShouldEqual, fmt.Sprintf("%v", v[:pos])) |
|
} |
|
} |
|
for _, id := range testdata[k].ObjID { |
|
ctx.So(objm[id], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestFlowCache(t *testing.T) { |
|
convey.Convey("FlowCache", t, func(ctx convey.C) { |
|
k := "flow" |
|
biz := testdata[k].AggrID[0] |
|
res, err := s.flowsByNet(cntx, biz) |
|
resm := map[int64]*net.Flow{} |
|
for _, item := range res { |
|
resm[item.ID] = item |
|
} |
|
ctx.So(err, convey.ShouldBeNil) |
|
for _, i := range testdata[k].RowRela[biz] { |
|
ctx.So(resm[i], convey.ShouldNotBeNil) |
|
} |
|
|
|
res2, err := s.flowIDByNet(cntx, biz) |
|
ctx.So(err, convey.ShouldBeNil) |
|
mmp := map[int64]int64{} |
|
for _, i := range testdata[k].RowRela[biz] { |
|
mmp[i] = i |
|
} |
|
ctx.So(len(res2), convey.ShouldEqual, len(testdata[k].RowRela[biz])) |
|
for _, i := range res2 { |
|
ctx.So(i, convey.ShouldEqual, mmp[i]) |
|
} |
|
|
|
res3, err := s.flows(cntx, testdata[k].ObjID, true) |
|
resm2 := map[int64]*net.Flow{} |
|
for _, item := range res3 { |
|
resm2[item.ID] = item |
|
} |
|
ctx.So(err, convey.ShouldBeNil) |
|
for _, i := range testdata[k].ObjID { |
|
ctx.So(resm2[i], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
} |
|
|
|
func TestTranArrGetKey(t *testing.T) { |
|
convey.Convey("TranArrGetKey", t, func(ctx convey.C) { |
|
objdest := &tranArr{} |
|
p1 := objdest.GetKey(0) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
} |
|
|
|
func TestTranArrAppendString(t *testing.T) { |
|
convey.Convey("TranArrAppendString", t, func(ctx convey.C) { |
|
objdest := &tranArr{} |
|
k := "tran" |
|
testdataprepare(k, testdata[k].RowObj) |
|
v := testdata[k].Caches[objdest.GetKey(testdata[k].ObjID[0])[0]] |
|
ok, err := objdest.AppendString(testdata[k].ObjID[0], v) |
|
ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(ok, convey.ShouldEqual, true) |
|
ctx.So(objdest.dest[0].ID, convey.ShouldEqual, testdata[k].ObjID[0]) |
|
}) |
|
}) |
|
} |
|
|
|
func TestTranArrAppendRaw(t *testing.T) { |
|
convey.Convey("TranArrAppendRaw", t, func(ctx convey.C) { |
|
objdest := &tranArr{} |
|
k := "tran" |
|
_, err := objdest.AppendRaw(cntx, s, testdata[k].ObjID, nil) |
|
objm := map[int64]*net.Transition{} |
|
for _, item := range objdest.dest { |
|
objm[item.ID] = item |
|
} |
|
ctx.Convey("Then err should be nil.missCache should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
for _, id := range testdata[k].ObjID { |
|
ctx.So(objm[id], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestTranCache(t *testing.T) { |
|
convey.Convey("TranCache", t, func(ctx convey.C) { |
|
k := "tran" |
|
biz := testdata[k].AggrID[0] |
|
res2, err := s.tranIDByNet(cntx, []int64{biz}, true, true) |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(fmt.Sprintf("%v", res2), convey.ShouldEqual, fmt.Sprintf("%v", testdata[k].RowRela[biz])) |
|
|
|
res3, err := s.transitions(cntx, testdata[k].ObjID, true) |
|
resm2 := map[int64]*net.Transition{} |
|
for _, item := range res3 { |
|
resm2[item.ID] = item |
|
} |
|
ctx.So(err, convey.ShouldBeNil) |
|
for _, i := range testdata[k].ObjID { |
|
ctx.So(resm2[i], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
} |
|
|
|
func TestDirArrGetKey(t *testing.T) { |
|
convey.Convey("dirArrGetKey", t, func(ctx convey.C) { |
|
objdest := &dirArr{} |
|
p1 := objdest.GetKey(0) |
|
ctx.Convey("Then p1 should not be nil.", func(ctx convey.C) { |
|
ctx.So(p1, convey.ShouldNotBeNil) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDirArrAppendString(t *testing.T) { |
|
convey.Convey("dirArrAppendString", t, func(ctx convey.C) { |
|
objdest := &dirArr{} |
|
k := "dir" |
|
testdataprepare(k, testdata2[k].RowObj) |
|
v := testdata2[k].Caches[objdest.GetKey(testdata2[k].ObjID[0])[0]] |
|
ok, err := objdest.AppendString(testdata2[k].ObjID[0], v) |
|
ctx.Convey("Then err should be nil.ok should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
ctx.So(ok, convey.ShouldEqual, true) |
|
ctx.So(objdest.dest[0].ID, convey.ShouldEqual, testdata2[k].ObjID[0]) |
|
}) |
|
}) |
|
} |
|
|
|
func TestDirArrAppendRaw(t *testing.T) { |
|
convey.Convey("dirArrAppendRaw", t, func(ctx convey.C) { |
|
objdest := &dirArr{} |
|
k := "dir" |
|
missCache, err := objdest.AppendRaw(cntx, s, testdata2[k].ObjID, nil) |
|
objm := map[int64]*net.Direction{} |
|
for _, item := range objdest.dest { |
|
objm[item.ID] = item |
|
} |
|
ctx.Convey("Then err should be nil.missCache should not be nil.", func(ctx convey.C) { |
|
ctx.So(err, convey.ShouldBeNil) |
|
for ck, v := range testdata2[k].Caches { |
|
if strings.Contains(ck, "flow_direction") || strings.Contains(ck, "transition_direction") { |
|
continue |
|
} |
|
pos := strings.Index(v, "ctime") |
|
if pos == -1 { |
|
ctx.So(fmt.Sprintf("%v", missCache[ck]), convey.ShouldEqual, fmt.Sprintf("%v", v)) |
|
} else { |
|
ctx.So(fmt.Sprintf("%v", missCache[ck][:pos]), convey.ShouldEqual, fmt.Sprintf("%v", v[:pos])) |
|
} |
|
} |
|
for _, id := range testdata2[k].ObjID { |
|
ctx.So(objm[id], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
}) |
|
} |
|
|
|
func TestDirCache(t *testing.T) { |
|
convey.Convey("DirCache", t, func(ctx convey.C) { |
|
k := "dir" |
|
biz := testdata2[k].AggrID |
|
tp := net.DirInput |
|
res, err := s.dirByFlow(cntx, biz, tp) |
|
resm := map[int64]*net.Direction{} |
|
for _, item := range res { |
|
resm[item.ID] = item |
|
} |
|
ctx.So(err, convey.ShouldBeNil) |
|
expected := []int64{} |
|
for _, i := range biz { |
|
expected = append(expected, testdata2[k].RowRela[i][tp]...) |
|
} |
|
for _, i := range expected { |
|
ctx.So(resm[i], convey.ShouldNotBeNil) |
|
} |
|
|
|
res2, err := s.dirByTran(cntx, biz, net.DirOutput, true) |
|
for _, item := range res2 { |
|
resm[item.ID] = item |
|
} |
|
ctx.So(err, convey.ShouldBeNil) |
|
expected2 := []int64{} |
|
for _, i := range biz { |
|
expected2 = append(expected2, testdata2[k].RowRela[i][tp]...) |
|
} |
|
for _, i := range expected2 { |
|
ctx.So(resm[i], convey.ShouldNotBeNil) |
|
} |
|
|
|
res3, err := s.directions(cntx, testdata2[k].ObjID) |
|
resm2 := map[int64]*net.Direction{} |
|
for _, item := range res3 { |
|
resm2[item.ID] = item |
|
} |
|
ctx.So(err, convey.ShouldBeNil) |
|
for _, i := range testdata2[k].ObjID { |
|
ctx.So(resm2[i], convey.ShouldNotBeNil) |
|
} |
|
}) |
|
}
|
|
|