From 023cf8f5f2e76c5582e1b3013a0d20f1132a4885 Mon Sep 17 00:00:00 2001 From: NikolasPetriti Date: Mon, 26 Jun 2023 16:59:56 +0200 Subject: [PATCH] Added coverage tests for cachecfg.go, datadbcfg.go, erscfg.go, fctemplate.go and rsrparser.go --- config/cachecfg_test.go | 66 +++++++++++++++++++ config/datadbcfg_test.go | 21 ++++++ config/erscfg_test.go | 19 ++++++ config/fctemplate_test.go | 40 ++++++++++++ config/rsrparser_test.go | 130 +++++++++++++++++++++++++++++++++++++ utils/pathitemlist_test.go | 51 --------------- 6 files changed, 276 insertions(+), 51 deletions(-) diff --git a/config/cachecfg_test.go b/config/cachecfg_test.go index 49dfd8265..885d27172 100644 --- a/config/cachecfg_test.go +++ b/config/cachecfg_test.go @@ -115,6 +115,72 @@ func TestCacheParamCfgloadFromJsonCfg(t *testing.T) { } } +func TestCacheCFGAsMapInterface(t *testing.T) { + c := CacheParamCfg{ + Limit: 1, + TTL: 1 * time.Second, + StaticTTL: true, + Precache: false, + } + + rcv := c.AsMapInterface() + exp := map[string]any{ + utils.LimitCfg: 1, + utils.TTLCfg: "1s", + utils.StaticTTLCfg: true, + utils.PrecacheCfg: false, + } + + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("recived %v, expected %v", rcv, exp) + } +} + + + +func TestCacheCFGAddTmpCaches(t *testing.T) { + c := CacheParamCfg{ + Limit: 1, + TTL: 1 * time.Second, + StaticTTL: true, + Precache: false, + } + + cc := CacheCfg{"test": &c} + + cc.AddTmpCaches() + + rcv := cc[utils.CacheRatingProfilesTmp] + exp := &CacheParamCfg{ + Limit: -1, + TTL: time.Minute, + } + + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("recived %v, expected %v", rcv, exp) + } +} + +func TestCacheCFGAsMappInterface(t *testing.T) { + c := CacheParamCfg{ + Limit: 1, + TTL: 1 * time.Second, + StaticTTL: true, + Precache: false, + } + + cc := CacheCfg{"test": &c} + + exp := c.AsMapInterface() + rcv := cc.AsMapInterface()["test"] + + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("recived %v, expected %v", rcv, exp) + } + +} + + /* func TestCacheCfgAsMapInterface(t *testing.T) { var cachecfg *CacheCfg diff --git a/config/datadbcfg_test.go b/config/datadbcfg_test.go index 6dea06bee..b55dc79f4 100644 --- a/config/datadbcfg_test.go +++ b/config/datadbcfg_test.go @@ -20,6 +20,7 @@ package config import ( "reflect" "testing" + "time" "github.com/cgrates/cgrates/utils" ) @@ -444,3 +445,23 @@ func TestDataDbCfgAsMapInterface(t *testing.T) { t.Errorf("Expected: %+v ,\n received: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv)) } } + +func TestDataDBCFGClone(t *testing.T) { + d := &DataDbCfg{ + DataDbType: "*redis", + DataDbHost: "127.0.0.1", + DataDbPort: "6379", + DataDbName: "10", + DataDbUser: "cgrates", + DataDbPass: "", + DataDbSentinelName: "", + QueryTimeout: 10 * time.Second, + RplFiltered: false, + } + + rcv := d.Clone() + + if !reflect.DeepEqual(rcv, d) { + t.Errorf("recived %v, expected %v", rcv, d) + } +} diff --git a/config/erscfg_test.go b/config/erscfg_test.go index 3be8042e2..c7a4f8385 100644 --- a/config/erscfg_test.go +++ b/config/erscfg_test.go @@ -329,3 +329,22 @@ func TestERsCfgAsMapInterface(t *testing.T) { t.Errorf("\nExpected: %+v\nReceived: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv)) } } + +func TestERSCFGClone(t *testing.T) { + ev := EventReaderCfg{} + ev2 := EventReaderCfg{} + + e := ERsCfg{ + Enabled: true, + SessionSConns: []string{"val1", "val2"}, + Readers: []*EventReaderCfg{&ev, &ev2}, + } + + rcv := e.Clone() + exp := &e + + if rcv.Enabled != exp.Enabled && !reflect.DeepEqual(rcv.SessionSConns, exp.SessionSConns) && !reflect.DeepEqual(rcv.Readers, exp.Readers) { + t.Errorf("recived %v, expected %v", rcv, exp) + } + +} diff --git a/config/fctemplate_test.go b/config/fctemplate_test.go index 298d6fadd..f0a848a34 100644 --- a/config/fctemplate_test.go +++ b/config/fctemplate_test.go @@ -329,3 +329,43 @@ func TestFCTemplateClone(t *testing.T) { t.Errorf("expected: %s ,received: %s", utils.ToJSON(initialSmpl), utils.ToJSON(cloned)) } } + +func TestFCTemplateGetPathSlice(t *testing.T) { + fc := FCTemplate{ + Tag: "Elem1", + Type: "*composed", + Path: "Elem1", + Filters: []string{"Filter1", "Filter2"}, + Value: NewRSRParsersMustCompile("Elem1", true, utils.INFIELD_SEP), + pathItems: utils.PathItems{utils.PathItem{Field: "test"}}, + pathSlice: []string{"val1", "val2"}, + } + + rcv := fc.GetPathSlice() + exp := []string{"val1", "val2"} + + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("recived %v, expected %v", rcv, exp) + } + +} + +func TestFCTemplateGetPathItems(t *testing.T) { + fc := FCTemplate{ + Tag: "Elem1", + Type: "*composed", + Path: "Elem1", + Filters: []string{"Filter1", "Filter2"}, + Value: NewRSRParsersMustCompile("Elem1", true, utils.INFIELD_SEP), + pathItems: utils.PathItems{utils.PathItem{Field: "test"}}, + pathSlice: []string{"val1", "val2"}, + } + + rcv := fc.GetPathItems() + exp := utils.PathItems{utils.PathItem{Field: "test"}} + + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("recived %v, expected %v", rcv, exp) + } + +} diff --git a/config/rsrparser_test.go b/config/rsrparser_test.go index 69faf29f3..7d66182be 100644 --- a/config/rsrparser_test.go +++ b/config/rsrparser_test.go @@ -19,6 +19,7 @@ along with this program. If not, see package config import ( + "errors" "reflect" "regexp" "testing" @@ -181,3 +182,132 @@ func TestRSRParserCompileConstant(t *testing.T) { t.Errorf("expecting: %+v, received: %+v", ePrsr, prsr) } } + +func TestRSRParserGetRule(t *testing.T) { + p := RSRParser{ + Rules: "Test", + } + p2 := RSRParser{ + Rules: "Test2", + } + + pp := RSRParsers{&p, &p2} + + rcv := pp.GetRule() + exp := "Test.Test2" + + if rcv != exp { + t.Errorf("expecting: %+v, received: %+v", exp, rcv) + } + +} + +func TestRSRParsersCompile(t *testing.T) { + + p := RSRParser{ + Rules: "Test", + } + p2 := RSRParser{ + Rules: "Test2", + } + + pp := RSRParsers{&p, &p2} + + rcv := pp.Compile() + + if rcv != nil { + t.Errorf("expecting: %+v, received: %+v", nil, rcv) + } +} + +func TestRSRParserParseDataProviderWithInterface(t *testing.T) { + + p := RSRParser{ + Rules: "Test", + } + p2 := RSRParser{ + Rules: "Test2", + } + + pp := RSRParsers{&p, &p2} + + rcv, err := pp.ParseDataProviderWithInterfaces(utils.MapStorage{}, ".") + exp := "TestTest2" + var expErr error = nil + + if err != expErr { + t.Fatalf("recived %v, expected %v", err, expErr) + } + + if rcv != exp { + t.Errorf("recived %s, expected %s", rcv, exp) + } + +} + +func TestRSRParserNewParserMustCompile(t *testing.T) { + + rcv := NewRSRParserMustCompile("test", false) + exp, _ := NewRSRParser("test", false) + + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("recived %v, expected %v", rcv, exp) + } +} + +func TestRSRParserregexpMatched(t *testing.T) { + + p := RSRParser{ + Rules: "Test", + } + + rcv := p.RegexpMatched() + + if rcv { + t.Error("was expecting false") + } +} + +func TestRSRParserParseDataProviderAsFloat64(t *testing.T) { + + type args struct { + dP utils.DataProvider + separator string + } + + type exp struct { + val float64 + err error + } + + tests := []struct { + name string + args args + exp exp + }{ + { + name: "", + args: args{dP: utils.MapStorage{}, separator: "."}, + exp: exp{val: 0, err: errors.New("empty path in parser")}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + p := RSRParser{ + Rules: "Test", + } + + rcv, err := p.ParseDataProviderAsFloat64(tt.args.dP, tt.args.separator) + + if err.Error() != tt.exp.err.Error() { + t.Fatalf("recived %s, expected %s", err, tt.exp.err) + } + + if rcv != tt.exp.val { + t.Errorf("recived %v, expected %v", rcv, tt.exp.val) + } + }) + } +} diff --git a/utils/pathitemlist_test.go b/utils/pathitemlist_test.go index cab9fe60a..0ebf91ccd 100644 --- a/utils/pathitemlist_test.go +++ b/utils/pathitemlist_test.go @@ -452,54 +452,3 @@ func TestPathItemListMoveAfter(t *testing.T) { t.Error("moved after") } } - -func TestPathItemList(t *testing.T) { - - p1 := PathItemElement{} - - pl := PathItemList{ - root: p1, - len: 3, - } - - p1.list = &pl - - p2 := PathItemElement{ - next: &p1, - list: &pl, - } - - p1.prev = &p2 - - p3 := PathItemElement{ - next: &p2, - list: &pl, - } - - p2.prev = &p3 - - pr4 := PathItemElement{} - - pl2 := PathItemList{ - root: pr4, - len: 3, - } - - pr4.list = &pl2 - - p5 := PathItemElement{ - next: &pr4, - list: &pl2, - } - - p6 := PathItemElement{ - next: &p5, - list: &pl2, - } - - p5.prev = &p6 - - //uncompleted - //pl.PushBackList(&pl2) - -}