From 763d6c7134feef75efa99267ad70c19dcd38cb26 Mon Sep 17 00:00:00 2001 From: arberkatellari Date: Thu, 13 Apr 2023 11:00:04 -0400 Subject: [PATCH] Add coverage tests for engine --- engine/datamanager_test.go | 58 +++++++++++++++++++ engine/libindex_health_test.go | 103 ++++++++++++++++++++++++++++++++- 2 files changed, 160 insertions(+), 1 deletion(-) diff --git a/engine/datamanager_test.go b/engine/datamanager_test.go index 2efde94fd..baa007853 100644 --- a/engine/datamanager_test.go +++ b/engine/datamanager_test.go @@ -10375,3 +10375,61 @@ func TestDMGetDispatcherHostCacheWriteErr1(t *testing.T) { t.Errorf("Expected error <%v>, received error <%v>", utils.ErrNotImplemented, err) } } + +func TestDMGetDispatcherHostCacheWriteErr2(t *testing.T) { + + cfgtmp := config.CgrConfig() + defer func() { + Cache = NewCacheS(config.CgrConfig(), nil, nil, nil) + config.SetCgrConfig(cfgtmp) + }() + + cfg := config.NewDefaultCGRConfig() + cfg.CacheCfg().ReplicationConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaReplicator)} + cfg.CacheCfg().Partitions[utils.MetaDispatcherHosts].Replicate = true + config.SetCgrConfig(cfg) + + data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + + cc := make(chan birpc.ClientConnector, 1) + cc <- &ccMock{ + + calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{ + utils.CacheSv1ReplicateSet: func(ctx *context.Context, args, reply interface{}) error { return utils.ErrNotImplemented }, + }, + } + + cM := NewConnManager(cfg) + cM.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, utils.MetaReplicator), utils.CacheSv1, cc) + dm := NewDataManager(data, cfg.CacheCfg(), cM) + + dH := &DispatcherHost{ + Tenant: "cgrates.org", + RemoteHost: &config.RemoteHost{ + ID: "ID", + Address: "127.0.0.1", + Transport: utils.MetaJSON, + ConnectAttempts: 1, + Reconnects: 1, + MaxReconnectInterval: 1, + ConnectTimeout: time.Nanosecond, + ReplyTimeout: time.Nanosecond, + TLS: true, + ClientKey: "key", + ClientCertificate: "ce", + CaCertificate: "ca", + }, + } + + if err := dm.dataDB.SetDispatcherHostDrv(context.Background(), dH); err != nil { + t.Error(err) + } + + Cache = NewCacheS(cfg, dm, cM, nil) + + _, err := dm.GetDispatcherHost(context.Background(), utils.CGRateSorg, dH.ID, false, true, utils.NonTransactional) + if err != utils.ErrNotImplemented { + t.Errorf("Expected error <%v>, received error <%v>", utils.ErrNotImplemented, err) + } + +} diff --git a/engine/libindex_health_test.go b/engine/libindex_health_test.go index a3d33c37c..63b3cca7f 100644 --- a/engine/libindex_health_test.go +++ b/engine/libindex_health_test.go @@ -500,7 +500,9 @@ func TestGetFltrIdxHealthgetIHObjFromCacheErr(t *testing.T) { t.Fatal(err) } - Cache.Set(context.Background(), utils.CacheAttributeProfiles, "cgrates.org:ATTR1", nil, []string{}, true, utils.NonTransactional) + if err := Cache.Set(context.Background(), utils.CacheAttributeProfiles, "cgrates.org:ATTR1", nil, []string{}, true, utils.NonTransactional); err != nil { + t.Error(err) + } if _, err := GetFltrIdxHealth(context.Background(), dm, useLtcache, useLtcache, useLtcache, utils.CacheAttributeFilterIndexes); err != utils.ErrNotFound { t.Errorf("Expected error <%v>, Received error <%v>", utils.ErrNotFound, err) @@ -534,3 +536,102 @@ func TestGetFltrIdxHealthIdxKeyFormatErr(t *testing.T) { } } + +func TestGetRevFltrIdxHealthFromObjGetKeysForPrefixErr(t *testing.T) { + + cfg := config.NewDefaultCGRConfig() + data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := NewDataManager(data, cfg.CacheCfg(), nil) + + useLtcache := ltcache.NewCache(0, 0, false, nil) + + expErr := "unsupported prefix in GetKeysForPrefix: " + if _, err := getRevFltrIdxHealthFromObj(context.Background(), dm, useLtcache, useLtcache, useLtcache, ""); err == nil || err.Error() != expErr { + t.Errorf("Expected error <%v>, Received error <%v>", expErr, err) + } + +} + +func TestGetRevFltrIdxHealthFromObjIHObjFromCacheErr(t *testing.T) { + + defer func() { + Cache = NewCacheS(config.CgrConfig(), nil, nil, nil) + }() + + cfg := config.NewDefaultCGRConfig() + data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := NewDataManager(data, cfg.CacheCfg(), nil) + + useLtcache := ltcache.NewCache(0, 0, false, nil) + if err := dm.SetAttributeProfile(context.Background(), &AttributeProfile{ + Tenant: "cgrates.org", + ID: "ATTR1", + FilterIDs: []string{"*string:~*req.Account:1001"}, + }, false); err != nil { + t.Fatal(err) + } + + if err := Cache.Set(context.Background(), utils.CacheAttributeProfiles, "cgrates.org:ATTR1", nil, []string{}, true, utils.NonTransactional); err != nil { + t.Error(err) + } + + if _, err := getRevFltrIdxHealthFromObj(context.Background(), dm, useLtcache, useLtcache, useLtcache, utils.CacheAttributeFilterIndexes); err != utils.ErrNotFound { + t.Errorf("Expected error <%v>, Received error <%v>", utils.ErrNotFound, err) + } + +} + +func TestGetRevFltrIdxHealthFromReverseGetKeysForPrefixErr(t *testing.T) { + + cfg := config.NewDefaultCGRConfig() + data := &DataDBMock{ + GetIndexesDrvF: func(ctx *context.Context, idxItmType, tntCtx, idxKey, transactionID string) (indexes map[string]utils.StringSet, err error) { + return nil, utils.ErrNotImplemented + }, + } + dm := NewDataManager(data, cfg.CacheCfg(), nil) + + useLtcache := ltcache.NewCache(0, 0, false, nil) + objCaches := make(map[string]*ltcache.Cache) + + rply := make(map[string]*ReverseFilterIHReply) + + expErr := "unsupported prefix in GetKeysForPrefix: " + if _, err := getRevFltrIdxHealthFromReverse(context.Background(), dm, useLtcache, useLtcache, objCaches, rply); err != utils.ErrNotImplemented { + t.Errorf("Expected error <%v>, Received error <%v>", expErr, err) + } + +} + +func TestGetRatesFromCacheGetRateProfileErr(t *testing.T) { + + cfg := config.NewDefaultCGRConfig() + data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := NewDataManager(data, cfg.CacheCfg(), nil) + + useLtcache := ltcache.NewCache(0, 0, false, nil) + + if _, err := getRatesFromCache(context.Background(), dm, useLtcache, "", ""); err != utils.ErrNotFound { + t.Errorf("Expected error <%v>, Received error <%v>", utils.ErrNotFound, err) + } + +} + +func TestGetRatesFromCacheObjValNil(t *testing.T) { + + defer func() { + Cache = NewCacheS(config.CgrConfig(), nil, nil, nil) + }() + + useLtcache := ltcache.NewCache(20, 20*time.Second, true, nil) + cfg := config.NewDefaultCGRConfig() + data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := NewDataManager(data, cfg.CacheCfg(), nil) + + useLtcache.Set("cgrates.org:ATTR1", nil, []string{}) + + if _, err := getRatesFromCache(context.Background(), dm, useLtcache, "cgrates.org", "ATTR1"); err != utils.ErrNotFound { + t.Errorf("Expected error <%v>, Received error <%v>", utils.ErrNotFound, err) + } + +}