From fd23a70bd163042ba512ac28bf083b7ea48c6c73 Mon Sep 17 00:00:00 2001 From: gezimbll Date: Thu, 1 Dec 2022 10:59:07 -0500 Subject: [PATCH] engine&utils:improving coverage tests --- engine/actions_test.go | 3 - engine/destinations_test.go | 68 ++++++++++++++++++++-- engine/routes_test.go | 11 +++- engine/storage_test.go | 40 +++++++++++++ engine/tpreader_test.go | 39 +++++++++++++ utils/mapstorage.go | 2 +- utils/mapstorage_test.go | 109 ++++++++++++++++++++++++++++++++++++ 7 files changed, 261 insertions(+), 11 deletions(-) diff --git a/engine/actions_test.go b/engine/actions_test.go index 8cdbe4700..ee61dc286 100644 --- a/engine/actions_test.go +++ b/engine/actions_test.go @@ -3344,7 +3344,6 @@ func TestResetAccountCDRSuccesful(t *testing.T) { } -/* func TestRemoveSessionCost(t *testing.T) { Cache.Clear(nil) cfg := config.NewDefaultCGRConfig() @@ -3378,7 +3377,6 @@ func TestRemoveSessionCost(t *testing.T) { dm.SetFilter(fl, true) Cache = NewCacheS(cfg, dm, nil) - SetDataStorage(dm) action := &Action{ ExtraParameters: "BalanceID;~*acnt.BalanceID;ActionID;~*act.ActionID;BalanceValue;~*acnt.BalanceValue", } @@ -3386,4 +3384,3 @@ func TestRemoveSessionCost(t *testing.T) { t.Error(err) } } -*/ diff --git a/engine/destinations_test.go b/engine/destinations_test.go index 9024f322d..39a92854e 100644 --- a/engine/destinations_test.go +++ b/engine/destinations_test.go @@ -21,8 +21,11 @@ import ( "encoding/json" "reflect" "testing" + "time" + "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/utils" + "github.com/cgrates/rpcclient" "github.com/nyaruka/phonenumbers" ) @@ -193,12 +196,11 @@ func TestDPNewLibNumber(t *testing.T) { } -/* func TestDMSetDestination(t *testing.T) { - Cache.Clear(nil) + cfg := config.NewDefaultCGRConfig() cfg.DataDbCfg().Items = map[string]*config.ItemOpt{ - utils.MetaDestinations: &config.ItemOpt{ + utils.MetaDestinations: { Replicate: true, }, } @@ -235,11 +237,67 @@ func TestDMSetDestination(t *testing.T) { Prefixes: []string{}, } dm := NewDataManager(db, cfg.CacheCfg(), connMngr) - config.SetCgrConfig(cfg) + Cache = NewCacheS(cfg, dm, nil) if err := dm.SetDestination(dest, utils.NonTransactional); err != nil { t.Error(err) } } -*/ + +func TestDMSetAccount(t *testing.T) { + Cache.Clear(nil) + cfg := config.NewDefaultCGRConfig() + cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicationConnsCfg)} + cfg.DataDbCfg().RplFiltered = false + cfg.DataDbCfg().Items = map[string]*config.ItemOpt{ + utils.MetaAccounts: { + Replicate: true, + }, + } + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- &ccMock{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.ReplicatorSv1SetAccount: func(args, reply interface{}) error { + *reply.(*string) = "reply" + return nil + }, + }, + } + connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicationConnsCfg): clientConn, + }) + db := NewInternalDB(nil, nil, true, map[string]*config.ItemOpt{ + utils.CacheAccounts: { + Limit: 3, + TTL: 2 * time.Minute, + StaticTTL: true, + Remote: true, + Replicate: true, + }, + }) + dm := NewDataManager(db, cfg.CacheCfg(), connMgr) + acc := &Account{ + ID: "id", + BalanceMap: map[string]Balances{ + "bal": { + { + Uuid: "uuid", + ID: "id", + Value: 21.3, + }, + }, + }, + UnitCounters: UnitCounters{}, + ActionTriggers: ActionTriggers{}, + AllowNegative: true, + Disabled: false, + } + + Cache = NewCacheS(cfg, dm, nil) + + if err := dm.SetAccount(acc); err != nil { + t.Error(err) + } + +} diff --git a/engine/routes_test.go b/engine/routes_test.go index 64cb78f69..a2103b278 100644 --- a/engine/routes_test.go +++ b/engine/routes_test.go @@ -1023,7 +1023,7 @@ func TestRouteServiceV1GetRoutes(t *testing.T) { t.Error(err) } - if err := rpS.V1GetRoutesList(args, &[]string{}); err == nil { + if err := rpS.V1GetRoutesList(args, &[]string{}); err == nil || err != utils.ErrNotFound { t.Error(err) } @@ -1733,7 +1733,8 @@ func TestRouteServicePopulateSortingData(t *testing.T) { } extraOpts := &optsGetRoutes{ - sortingStrategy: utils.MetaLoad, + sortingStrategy: utils.MetaLoad, + sortingParameters: []string{"sort1"}, } exp := &SortedRoute{ RouteID: "id", @@ -1759,4 +1760,10 @@ func TestRouteServicePopulateSortingData(t *testing.T) { } else if !reflect.DeepEqual(exp.SortingData, sroutes.SortingData) { t.Errorf("expected %+v,received %+v", utils.ToJSON(exp), utils.ToJSON(sroutes)) } + + extraOpts.sortingStrategy = "other" + + if _, pass, err := routeService.populateSortingData(ev, route, extraOpts); err != nil || !pass { + t.Error(err) + } } diff --git a/engine/storage_test.go b/engine/storage_test.go index 1b5a4d9d1..4f6a8abca 100644 --- a/engine/storage_test.go +++ b/engine/storage_test.go @@ -21,6 +21,7 @@ import ( "testing" "time" + "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/utils" ) @@ -361,3 +362,42 @@ func BenchmarkMarshallerBincStoreRestore(b *testing.B) { ms.Unmarshal(result, ub1) } } + +func TestIDBRemoveIndexesDrv(t *testing.T) { + idb := NewInternalDB(nil, nil, true, map[string]*config.ItemOpt{ + "chID": { + Limit: 3, + TTL: 4 * time.Minute, + StaticTTL: false, + Remote: true, + Replicate: true, + + RouteID: "route", + APIKey: "api", + }, + "chID2": { + + Limit: 3, + TTL: 4 * time.Minute, + StaticTTL: false, + Remote: true, + Replicate: true, + + RouteID: "route", + APIKey: "api", + }, + }, + ) + idb.db.Set("chID", "itmID", true, []string{utils.EmptyString}, true, "trID") + idb.db.Set("chID2", "itmIDv", true, []string{"grpID"}, true, "trID") + + if err := idb.RemoveIndexesDrv("chID", utils.EmptyString, utils.EmptyString); err != nil { + t.Error(err) + } + if err := idb.RemoveIndexesDrv("chID2", "itmID", "v"); err != nil { + t.Error(err) + } + if has := idb.db.HasGroup("chID", utils.EmptyString); has { + t.Error("group should be removed") + } +} diff --git a/engine/tpreader_test.go b/engine/tpreader_test.go index 7b89ecc34..0757e397e 100644 --- a/engine/tpreader_test.go +++ b/engine/tpreader_test.go @@ -1154,3 +1154,42 @@ func TestTpReaderIsValid(t *testing.T) { } } + +func TestTpReaderLoadAccountActions(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + tscache := ltcache.NewTransCache( + map[string]*ltcache.CacheConfig{ + utils.CacheTBLTPAccountActions: { + MaxItems: 3, + TTL: time.Minute * 30, + StaticTTL: false, + OnEvicted: func(itmID string, value interface{}) { + }, + }}, + ) + tscache.Set(utils.CacheTBLTPAccountActions, "*prfitemId", &utils.TPAccountActions{ + TPid: "tp_acc1", + Account: "acc1", + Tenant: "tn1", + }, []string{"groupId"}, true, "tId") + tscache.Set(utils.CacheTBLTPAccountActions, "*prfitemId2", &utils.TPAccountActions{ + TPid: "tp_acc2", + Account: "acc2", + Tenant: "tn2", + ActionPlanId: "actionplans", + }, []string{"groupId"}, true, "tId") + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + db.db = tscache + tpr, err := NewTpReader(db, db, "*prf", "local", nil, nil, true) + if err != nil { + t.Error(err) + } + if err := tpr.LoadAccountActions(); err == nil || err.Error() != fmt.Sprintf("could not get action plan for tag %q", "actionplans") { + + t.Error(err) + } + tpr.dm = nil + if err := tpr.LoadAccountActions(); err == nil { + t.Error(err) + } +} diff --git a/utils/mapstorage.go b/utils/mapstorage.go index ad4cabbbf..4c600cd1b 100644 --- a/utils/mapstorage.go +++ b/utils/mapstorage.go @@ -393,7 +393,7 @@ func (sm *SecureMapStorage) Remove(fldPath []string) (err error) { func (sm *SecureMapStorage) Clone() (smClone *SecureMapStorage) { sm.RLock() smClone = new(SecureMapStorage) - smClone.ms = smClone.ms.Clone() + smClone.ms = sm.ms.Clone() sm.RUnlock() return } diff --git a/utils/mapstorage_test.go b/utils/mapstorage_test.go index 5a43eeae5..590ff33f0 100644 --- a/utils/mapstorage_test.go +++ b/utils/mapstorage_test.go @@ -916,3 +916,112 @@ func TestMSgetPathFromValue(t *testing.T) { ) } } + +func TestSecureMapStorageString(t *testing.T) { + sm := &SecureMapStorage{ms: MapStorage{ + "field1": 23, + "field2": []string{"ms1", "ms2"}, + }} + exp := "{\"field1\":23,\"field2\":[\"ms1\",\"ms2\"]}" + if val := sm.String(); val != exp { + t.Errorf("expected %+s,received %+s", exp, val) + } +} + +func TestSecureMapStorageFieldAsInterface(t *testing.T) { + sm := &SecureMapStorage{ms: MapStorage{ + "field1": []string{"val1", "val2"}, + }} + if val, err := sm.FieldAsInterface([]string{"field1[0]"}); err != nil { + + t.Error(err) + } else if val.(string) != sm.ms["field1"].([]string)[0] { + t.Errorf("expected %s,received %v", val, sm.ms["field1"].([]string)[0]) + } +} + +func TestSecureMapStorageFieldAsString(t *testing.T) { + sm := &SecureMapStorage{ms: MapStorage{ + "field1": []string{"val1", "val2"}, + }} + if val, err := sm.FieldAsString([]string{"field1[0]"}); err != nil { + t.Error(err) + } else if val != sm.ms["field1"].([]string)[0] { + t.Errorf("expected %s,received %v", val, sm.ms["field1"].([]string)[0]) + } + +} +func TestSecureMapStorageSet(t *testing.T) { + sm := &SecureMapStorage{ms: MapStorage{ + "field": map[string]interface{}{}, + }} + exp := MapStorage{ + "test": "val", + } + if err := sm.Set([]string{"field2"}, MapStorage{"test": "val"}); err != nil { + t.Error(err) + } + if v, has := sm.ms["field2"]; !has { + t.Error("expected") + } else if !reflect.DeepEqual(v, exp) { + t.Errorf("expected %v,reeived %v", ToJSON(exp), ToJSON(v)) + } + +} + +func TestSecureMapStorageGetKeys(t *testing.T) { + sm := &SecureMapStorage{ + ms: MapStorage{ + "field1": map[string]interface{}{ + "subfield1": []string{"subkey"}, + }, + "field2": MapStorage{ + "mapfield": map[string]interface{}{ + "submapfield2": []string{"subkey"}, + }, + }, + }, + } + exp := []string{"*pre.field1.subfield1[0]", "*pre.field2.mapfield.submapfield2[0]"} + val := sm.GetKeys(true, 3, "*pre") + sort.Slice(val, func(i, j int) bool { + return val[i] < val[j] + }) + if !reflect.DeepEqual(val, exp) { + t.Errorf("expected %+v,received %+v", ToJSON(exp), ToJSON(val)) + } +} + +func TestSecureMapStorageRemove(t *testing.T) { + sm := &SecureMapStorage{ + ms: MapStorage{ + "field": map[string]interface{}{ + "subfield": uint16(3), + }, + }, + } + if err := sm.Remove([]string{"field", "subfield"}); err != nil { + t.Error(err) + } + if _, has := sm.ms["field"].(map[string]interface{})["subfield"]; has { + t.Error("should been removed") + } +} + +func TestSecureMapStorageClone(t *testing.T) { + sm := &SecureMapStorage{ + ms: MapStorage{ + "field1": []string{"val1", "val2"}, + "field2": "val", + }, + } + if val := sm.Clone(); !reflect.DeepEqual(val, sm) { + t.Errorf("expected %+v,received %+v", ToJSON(sm.ms), ToJSON(val.ms)) + } +} + +func TestNewSecureMapStorage(t *testing.T) { + if sm := NewSecureMapStorage(); reflect.DeepEqual(sm, nil) { + t.Error("should receive new secure map") + } +}