From 78e05629e036c3ff629bd6fc14ffd4c6d848927e Mon Sep 17 00:00:00 2001 From: nickolasdaniel Date: Tue, 5 Apr 2022 17:36:34 +0300 Subject: [PATCH] Coverage tests --- apis/accounts_test.go | 91 +++++++++++++++++++ apis/cache_test.go | 203 ++++++++++++++++++++++++++++++++++++++++++ apis/ees_test.go | 31 +++++++ apis/libadmin_test.go | 138 ++++++++++++++++++++++++++++ 4 files changed, 463 insertions(+) diff --git a/apis/accounts_test.go b/apis/accounts_test.go index 1a6abfd7d..c035ae1d1 100644 --- a/apis/accounts_test.go +++ b/apis/accounts_test.go @@ -2357,3 +2357,94 @@ func TestAccountsGetAccountIDsPaginateErr(t *testing.T) { dm.DataDB().Flush(utils.EmptyString) } + +func TestAccountsRefundCharges(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.GeneralCfg().DefaultCaching = utils.MetaNone + connMgr := engine.NewConnManager(cfg) + dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := engine.NewDataManager(dataDB, nil, connMgr) + acc := accounts.NewAccountS(cfg, &engine.FilterS{}, connMgr, dm) + accS := NewAccountSv1(acc) + + var reply string + + args := &utils.APIEventCharges{ + Tenant: "cgrates.org", + EventCharges: &utils.EventCharges{ + Abstracts: nil, + }, + } + + if err := accS.RefundCharges(context.Background(), args, &reply); err != nil { + t.Error(err) + } + if reply != utils.OK { + t.Errorf("Expected %v\n but received %v", utils.OK, reply) + } +} + +func TestAccountsGetAccount(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.GeneralCfg().DefaultCaching = utils.MetaNone + connMgr := engine.NewConnManager(cfg) + dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := engine.NewDataManager(dataDB, nil, connMgr) + acc := accounts.NewAccountS(cfg, &engine.FilterS{}, connMgr, dm) + accS := NewAccountSv1(acc) + cfg.GeneralCfg().DefaultCaching = utils.MetaNone + admS := NewAdminSv1(cfg, dm, nil) + acc_args := &utils.AccountWithAPIOpts{ + Account: &utils.Account{ + Tenant: "cgrates.org", + ID: "test_ID1", + Opts: map[string]interface{}{}, + Balances: map[string]*utils.Balance{ + "VoiceBalance": { + ID: "VoiceBalance", + Weights: utils.DynamicWeights{ + { + Weight: 12, + }, + }, + Type: "*abstract", + Opts: map[string]interface{}{ + "Destination": 10, + }, + CostIncrements: []*utils.CostIncrement{ + { + RecurrentFee: utils.NewDecimal(1, 0), + Increment: utils.NewDecimal(1, 1), + }, + }, + Units: utils.NewDecimal(0, 0), + }, + }, + Weights: utils.DynamicWeights{ + { + Weight: 10, + }, + }, + }, + APIOpts: nil, + } + + var setRply string + err := admS.SetAccount(context.Background(), acc_args, &setRply) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + + var reply utils.Account + + args := &utils.TenantIDWithAPIOpts{ + TenantID: utils.NewTenantID("cgrates.org:test_ID1"), + } + + if err := accS.GetAccount(context.Background(), args, &reply); err != nil { + t.Error(err) + } + if !reflect.DeepEqual(&reply, acc_args.Account) { + t.Errorf("Expected %v\n but received %v", reply, acc_args.Account) + } +} diff --git a/apis/cache_test.go b/apis/cache_test.go index 9b4a4e8e8..0b4eac024 100644 --- a/apis/cache_test.go +++ b/apis/cache_test.go @@ -21,11 +21,13 @@ package apis import ( "reflect" "testing" + "time" "github.com/cgrates/birpc/context" "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/engine" "github.com/cgrates/cgrates/utils" + "github.com/cgrates/ltcache" ) func TestCacheHasItemAndGetItem(t *testing.T) { @@ -275,3 +277,204 @@ func TestCacheReloadCache(t *testing.T) { t.Errorf("Expected %+v, received %+v", utils.ErrNotFound, err) } } + +func TestGetCacheStats(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + ch := engine.NewCacheS(cfg, dm, nil) + cache := NewCacheSv1(ch) + ch.SetWithoutReplicate(utils.CacheAttributeProfiles, "cgrates.org:TestGetCacheStats", nil, nil, true, utils.NonTransactional) + var reply map[string]*ltcache.CacheStats + + args := &utils.AttrCacheIDsWithAPIOpts{ + Tenant: "cgrates.org", + APIOpts: map[string]interface{}{}, + CacheIDs: []string{utils.CacheAttributeProfiles}, + } + if err := cache.GetCacheStats(context.Background(), args, &reply); err != nil { + t.Error(err) + } + if reply[utils.CacheAttributeProfiles].Items != 1 { + t.Errorf("Expected 1\n but received %v", reply[utils.CacheAttributeProfiles].Items) + } +} + +func TestPrecacheStatus(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + ch := engine.NewCacheS(cfg, dm, nil) + cache := NewCacheSv1(ch) + + var reply map[string]string + + args := &utils.AttrCacheIDsWithAPIOpts{ + Tenant: "cgrates.org", + APIOpts: map[string]interface{}{}, + CacheIDs: []string{utils.CacheAttributeProfiles}, + } + if err := cache.PrecacheStatus(context.Background(), args, &reply); err != nil { + t.Error(err) + } + exp := map[string]string{ + utils.CacheAttributeProfiles: utils.MetaPrecaching, + } + if !reflect.DeepEqual(reply, exp) { + t.Errorf("Expected %v\n but received %v", exp, reply) + } + // fmt.Println(reply) +} + +func TestHasGroup(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + ch := engine.NewCacheS(cfg, dm, nil) + cache := NewCacheSv1(ch) + + var reply bool + + args := &utils.ArgsGetGroupWithAPIOpts{ + Tenant: "cgrates.org", + APIOpts: map[string]interface{}{}, + ArgsGetGroup: utils.ArgsGetGroup{ + CacheID: utils.CacheAttributeProfiles, + GroupID: "Group", + }, + } + if err := cache.HasGroup(context.Background(), args, &reply); err != nil { + t.Error(err) + } + if reply { + t.Error("Expected false") + } +} + +func TestGetGroupItemIDs(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + ch := engine.NewCacheS(cfg, dm, nil) + cache := NewCacheSv1(ch) + + ch.SetWithoutReplicate(utils.CacheAttributeProfiles, "cgrates.org:TestGetCacheStats", nil, []string{"AttrGroup"}, true, utils.NonTransactional) + + var reply []string + + args := &utils.ArgsGetGroupWithAPIOpts{ + Tenant: "cgrates.org", + APIOpts: map[string]interface{}{}, + ArgsGetGroup: utils.ArgsGetGroup{ + CacheID: utils.CacheAttributeProfiles, + GroupID: "AttrGroup", + }, + } + + if err := cache.GetGroupItemIDs(context.Background(), args, &reply); err != nil { + t.Error(err) + } + exp := []string{"cgrates.org:TestGetCacheStats"} + if !reflect.DeepEqual(reply, exp) { + t.Errorf("Expected %v\n but received %v", exp, reply) + } +} + +func TestRemoveGroup(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + ch := engine.NewCacheS(cfg, dm, nil) + cache := NewCacheSv1(ch) + + var reply string + + args := &utils.ArgsGetGroupWithAPIOpts{ + Tenant: "cgrates.org", + APIOpts: map[string]interface{}{}, + ArgsGetGroup: utils.ArgsGetGroup{ + CacheID: utils.CacheAttributeProfiles, + GroupID: "AttrGroup", + }, + } + + if err := cache.RemoveGroup(context.Background(), args, &reply); err != nil { + t.Error(err) + } + if reply != utils.OK { + t.Errorf("Expected OK\n but received %v", reply) + } +} + +func TestReplicateSet(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + ch := engine.NewCacheS(cfg, dm, nil) + cache := NewCacheSv1(ch) + + var reply string + + args := &utils.ArgCacheReplicateSet{ + CacheID: utils.CacheAttributeProfiles, + Tenant: "cgrates.org", + } + + if err := cache.ReplicateSet(context.Background(), args, &reply); err != nil { + t.Error(err) + } + if reply != utils.OK { + t.Errorf("Expected OK\n but received %v", reply) + } +} + +func TestReplicateRemove(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + ch := engine.NewCacheS(cfg, dm, nil) + cache := NewCacheSv1(ch) + + var reply string + + args := &utils.ArgCacheReplicateRemove{ + CacheID: utils.CacheAttributeProfiles, + Tenant: "cgrates.org", + } + + if err := cache.ReplicateRemove(context.Background(), args, &reply); err != nil { + t.Error(err) + } + if reply != utils.OK { + t.Errorf("Expected OK\n but received %v", reply) + } +} + +func TestGetItemExpiryTime(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + ch := engine.NewCacheS(cfg, dm, nil) + cache := NewCacheSv1(ch) + + var reply time.Time + + args := &utils.ArgsGetCacheItemWithAPIOpts{ + Tenant: "cgrates.org", + ArgsGetCacheItem: utils.ArgsGetCacheItem{ + CacheID: utils.CacheAttributeProfiles, + }, + } + + if err := cache.GetItemExpiryTime(context.Background(), args, &reply); err == nil || err != utils.ErrNotFound { + t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err) + } +} diff --git a/apis/ees_test.go b/apis/ees_test.go index 20763b5c7..dfd2d36a5 100644 --- a/apis/ees_test.go +++ b/apis/ees_test.go @@ -88,3 +88,34 @@ func TestEeSProcessEvent(t *testing.T) { t.Error(err) } } + +func TestArchiveEventsInReply(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + // cfg.EEsCfg().Exporters[0].Type = "*fileCSV" + cfg.EEsCfg().Exporters[0].ID = "SQLExporterFull" + newIDb := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + newDM := engine.NewDataManager(newIDb, cfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cfg, nil, newDM) + eeS := ees.NewEventExporterS(cfg, filterS, nil) + cS := NewEeSv1(eeS) + + args := &ees.ArchiveEventsArgs{ + Tenant: "cgrates.org", + APIOpts: map[string]interface{}{ + utils.MetaExporterID: "SQLExporterFull", + }, + Events: []*utils.EventsWithOpts{ + { + Event: map[string]interface{}{ + "Account": "1001", + }, + }, + }, + } + + var reply []byte + errExp := "exporter with ID: SQLExporterFull is not synchronous" + if err := cS.ArchiveEventsInReply(context.Background(), args, &reply); err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } +} diff --git a/apis/libadmin_test.go b/apis/libadmin_test.go index 7229f1f97..f7fbd56f8 100644 --- a/apis/libadmin_test.go +++ b/apis/libadmin_test.go @@ -102,3 +102,141 @@ func TestCallCacheForFilter(t *testing.T) { t.Errorf("Expected %s ,received: %s", utils.ToJSON(exp), utils.ToJSON(rpl)) } } + +func TestCallCache(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.GeneralCfg().DefaultCaching = utils.MetaNone + connMgr := engine.NewConnManager(cfg) + dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := engine.NewDataManager(dataDB, nil, connMgr) + admS := NewAdminSv1(cfg, dm, connMgr) + admS.cfg.AdminSCfg().CachesConns = []string{"*internal"} + opts := map[string]interface{}{ + utils.MetaCache: utils.MetaNone, + } + errExp := "UNSUPPORTED_SERVICE_METHOD" + + // Reload + if err := admS.CallCache(context.Background(), utils.MetaReload, "cgrates.org", "", "", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + // Load + if err := admS.CallCache(context.Background(), utils.MetaLoad, "cgrates.org", "", "", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + // Clear - Thresholds + if err := admS.CallCache(context.Background(), utils.MetaClear, "cgrates.org", utils.CacheThresholdProfiles, "", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + // Clear - Resources + if err := admS.CallCache(context.Background(), utils.MetaClear, "cgrates.org", utils.CacheResourceProfiles, "", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + // Clear - Stats + if err := admS.CallCache(context.Background(), utils.MetaClear, "cgrates.org", utils.CacheStatQueueProfiles, "", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } +} + +func TestCallCacheForRemoveIndexes(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.GeneralCfg().DefaultCaching = utils.MetaNone + connMgr := engine.NewConnManager(cfg) + dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := engine.NewDataManager(dataDB, nil, connMgr) + admS := NewAdminSv1(cfg, dm, connMgr) + admS.cfg.AdminSCfg().CachesConns = []string{"*internal"} + opts := map[string]interface{}{ + utils.MetaCache: utils.MetaNone, + } + errExp := "UNSUPPORTED_SERVICE_METHOD" + + // Reload + if err := admS.callCacheForRemoveIndexes(context.Background(), utils.MetaReload, "cgrates.org", "", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + // Load + if err := admS.callCacheForRemoveIndexes(context.Background(), utils.MetaLoad, "cgrates.org", "", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + // Remove + if err := admS.callCacheForRemoveIndexes(context.Background(), utils.MetaRemove, "cgrates.org", "", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + if err := admS.callCacheForRemoveIndexes(context.Background(), utils.MetaClear, "cgrates.org", "", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } +} + +func TestCallCacheForComputeIndexes(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.GeneralCfg().DefaultCaching = utils.MetaNone + connMgr := engine.NewConnManager(cfg) + dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := engine.NewDataManager(dataDB, nil, connMgr) + admS := NewAdminSv1(cfg, dm, connMgr) + admS.cfg.AdminSCfg().CachesConns = []string{"*internal"} + opts := map[string]interface{}{ + utils.MetaCache: utils.MetaNone, + } + errExp := "UNSUPPORTED_SERVICE_METHOD" + + // Reload + if err := admS.callCacheForComputeIndexes(context.Background(), utils.MetaReload, "cgrates.org", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + // Load + if err := admS.callCacheForComputeIndexes(context.Background(), utils.MetaLoad, "cgrates.org", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + // Remove + if err := admS.callCacheForComputeIndexes(context.Background(), utils.MetaRemove, "cgrates.org", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + if err := admS.callCacheForComputeIndexes(context.Background(), utils.MetaClear, "cgrates.org", nil, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } +} + +func TestCallCacheMultiple(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.GeneralCfg().DefaultCaching = utils.MetaNone + connMgr := engine.NewConnManager(cfg) + dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := engine.NewDataManager(dataDB, nil, connMgr) + admS := NewAdminSv1(cfg, dm, connMgr) + admS.cfg.AdminSCfg().CachesConns = []string{"*internal"} + opts := map[string]interface{}{ + utils.MetaCache: utils.MetaNone, + } + errExp := "UNSUPPORTED_SERVICE_METHOD" + + // Reload + if err := admS.callCacheMultiple(context.Background(), utils.MetaReload, "cgrates.org", "", []string{"itemID"}, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + // Load + if err := admS.callCacheMultiple(context.Background(), utils.MetaLoad, "cgrates.org", "", []string{"itemID"}, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + // Remove + if err := admS.callCacheMultiple(context.Background(), utils.MetaRemove, "cgrates.org", "", []string{"itemID"}, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } + + if err := admS.callCacheMultiple(context.Background(), utils.MetaClear, "cgrates.org", "", []string{"itemID"}, opts); err == nil || err.Error() != errExp { + t.Errorf("Expected %v\n but received %v", errExp, err) + } +}