Coverage tests

2026-02-16 05:39:54 +05:00 · 2022-04-05 17:36:34 +03:00
parent ae15db06f9
commit 78e05629e0
4 changed files with 463 additions and 0 deletions
--- 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)
+	}
+}
--- 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)
+	}
+}
--- 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)
+	}
+}
--- 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)
+	}
+}