Improving coverage of unit tests

engine/account_test.go

@@ -2445,7 +2445,6 @@ func TestAccountSetRrecurrentAction(t *testing.T) {
 	if err := aT.Execute(ub); err != nil {
 		t.Error(err)
 	}
-
 }
 
 func TestAccountEnableAccAct(t *testing.T) {
@@ -2505,7 +2504,53 @@ func TestAccountEnableAccAct(t *testing.T) {
 	if acc, err := dm.GetAccount("cgrates.org:1001"); err != nil || acc.Disabled {
 		t.Error(err)
 	}
+	dm.RemoveActions("ACT_1", utils.NonTransactional)
+	a.ActionType = utils.DISABLE_ACCOUNT
+	dm.SetActions("ACT_1", Actions{a}, utils.NonTransactional)
+	acc.ExecuteActionTriggers(a)
+	if _, err := dm.GetAccount("cgrates.org:1001"); err != nil {
+		t.Error(err)
+	}
+}
 
+func TestAccountPublishAct(t *testing.T) {
+	cfg, _ := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+	defer func() {
+		cfg2, _ := config.NewDefaultCGRConfig()
+		config.SetCgrConfig(cfg2)
+		SetDataStorage(tmpDm)
+	}()
+	ub := &Account{
+		ID: "cgrates.org:1002",
+		BalanceMap: map[string]Balances{
+			utils.MONETARY: {
+				&Balance{
+					Value:          10,
+					DestinationIDs: utils.StringMap{"DEST1": true, "DEST2": false},
+					ExpirationDate: time.Date(2022, 12, 23, 20, 0, 0, 0, time.UTC),
+				},
+			}},
+		ActionTriggers: ActionTriggers{
+			&ActionTrigger{
+				Balance: &BalanceFilter{
+
+					Type:           utils.StringPointer(utils.MONETARY),
+					DestinationIDs: &utils.StringMap{"DEST1": true, "DEST2": false},
+					ExpirationDate: utils.TimePointer(time.Date(2022, 12, 23, 20, 0, 0, 0, time.UTC)),
+				},
+
+				ThresholdValue: 2,
+				ThresholdType:  utils.TRIGGER_BALANCE_EXPIRED,
+				ActionsID:      "TEST_ACTIONS_ORDER"},
+		},
+	}
+	a := &Action{}
+	SetDataStorage(dm)
+
+	ub.ExecuteActionTriggers(a)
 }
 
 /*********************************** Benchmarks *******************************/

engine/caches_test.go

@@ -251,5 +251,16 @@ func TestCachesRPCCall(t *testing.T) {
 	} else if !reflect.DeepEqual(reply, []string{"cgrates:TH1"}) {
 		t.Errorf("Expected %v", []string{"cgrates:TH1"})
 	}
-
+}
+
+func TestCacheSPreCache(t *testing.T) {
+	cfg, _ := config.NewDefaultCGRConfig()
+	cfg.CacheCfg()[utils.CacheAttributeProfiles].Precache = true
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+	chS := NewCacheS(cfg, dm)
+	Cache.Clear(nil)
+	if err := chS.Precache(); err != nil {
+		t.Error(err)
+	}
 }

engine/datamanager_test.go

@@ -1057,3 +1057,165 @@ func TestDMGetTiming(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func TestDmDispatcherProfile(t *testing.T) {
+	cfg, _ := config.NewDefaultCGRConfig()
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+
+	fltr := &Filter{
+		Tenant: "cgrates.org",
+		ID:     "DSP_FLT",
+		Rules: []*FilterRule{
+			{
+				Element: utils.DynamicDataPrefix + utils.MetaReq + utils.NestingSep + utils.Account,
+				Type:    utils.MetaString,
+				Values:  []string{"2009"},
+			},
+		},
+	}
+	fltr2 := &Filter{
+		Tenant: "cgrates.org",
+		ID:     "DSP_FLT2",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaGreaterOrEqual,
+				Element: utils.DynamicDataPrefix + utils.MetaReq + utils.NestingSep + utils.Weight,
+				Values:  []string{"15.0"},
+			},
+		},
+	}
+	dm.SetFilter(fltr)
+	dm.SetFilter(fltr2)
+	dpp := &DispatcherProfile{
+		Tenant:     "cgrates.org",
+		ID:         "DSP1",
+		FilterIDs:  []string{"DSP_FLT"},
+		Strategy:   utils.MetaFirst,
+		Subsystems: []string{utils.MetaAttributes, utils.MetaSessionS},
+		Weight:     20,
+		Hosts: DispatcherHostProfiles{
+			&DispatcherHostProfile{
+				ID:        "ALL2",
+				FilterIDs: []string{},
+				Weight:    20,
+				Params:    make(map[string]interface{}),
+			},
+			&DispatcherHostProfile{
+				ID:        "ALL",
+				FilterIDs: []string{},
+				Weight:    10,
+				Params:    make(map[string]interface{}),
+			},
+		},
+	}
+	dm.SetDispatcherProfile(dpp, true)
+	dpp.FilterIDs = []string{"DSP_FLT2"}
+	if err := dm.SetDispatcherProfile(dpp, true); err != nil {
+		t.Error(err)
+	}
+
+}
+
+func TestDmGetSQRemote(t *testing.T) {
+	cfg, _ := config.NewDefaultCGRConfig()
+	cfg.DataDbCfg().Items[utils.MetaStatQueues].Remote = true
+	cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	Cache.Clear(nil)
+	defer func() {
+		cfg2, _ := config.NewDefaultCGRConfig()
+		config.SetCgrConfig(cfg2)
+	}()
+	clientConnn := make(chan rpcclient.ClientConnector, 1)
+	clientConnn <- clMock(func(serviceMethod string, _, reply interface{}) error {
+		if serviceMethod == utils.ReplicatorSv1GetStatQueue {
+
+			*reply.(*StoredStatQueue) = StoredStatQueue{
+				Tenant:    "cgrates.org",
+				ID:        "SQ1",
+				SQItems:   []SQItem{},
+				SQMetrics: map[string][]byte{},
+			}
+			return nil
+		}
+
+		return utils.ErrNotFound
+	})
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConnn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	if _, err := dm.GetStatQueue("cgrates.org", "SQ1", false, true, utils.NonTransactional); err == nil {
+		t.Error(err)
+	}
+	// unfinished
+}
+
+func TestRemoveThresholdRpl(t *testing.T) {
+	cfg, _ := config.NewDefaultCGRConfig()
+	cfg.DataDbCfg().Items[utils.MetaThresholds].Replicate = true
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	Cache.Clear(nil)
+	defer func() {
+		cfg2, _ := config.NewDefaultCGRConfig()
+		config.SetCgrConfig(cfg2)
+	}()
+	clientConnn := make(chan rpcclient.ClientConnector, 1)
+	clientConnn <- clMock(func(serviceMethod string, _, reply interface{}) error {
+		if serviceMethod == utils.ReplicatorSv1RemoveThreshold {
+
+			return nil
+		}
+
+		return utils.ErrNotFound
+	})
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConnn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	if err := dm.RemoveThreshold("cgrates.org", "TH1", utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+
+}
+
+func TestRemoveDispatcherPrfRpl(t *testing.T) {
+	cfg, _ := config.NewDefaultCGRConfig()
+	cfg.DataDbCfg().Items[utils.MetaDispatcherProfiles].Replicate = true
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	Cache.Clear(nil)
+	defer func() {
+		cfg2, _ := config.NewDefaultCGRConfig()
+		config.SetCgrConfig(cfg2)
+	}()
+	clientConnn := make(chan rpcclient.ClientConnector, 1)
+	clientConnn <- clMock(func(serviceMethod string, _, reply interface{}) error {
+		if serviceMethod == utils.ReplicatorSv1RemoveDispatcherProfile {
+
+			return nil
+		}
+
+		return utils.ErrNotFound
+	})
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConnn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	dpp := &DispatcherProfile{
+		Tenant:     "cgrates.org",
+		ID:         "DSP_Test2",
+		Subsystems: []string{utils.MetaAttributes},
+		Weight:     20,
+	}
+	dm.SetDispatcherProfile(dpp, true)
+	config.SetCgrConfig(cfg)
+	if err := dm.RemoveDispatcherProfile("cgrates.org", "DSP_Test2", utils.NonTransactional, true); err != nil {
+		t.Error(err)
+	}
+
+}

engine/storage_test.go

@@ -1259,7 +1259,6 @@ func TestTpRLoadAll(t *testing.T) {
 			ActionTriggersId: "STANDARD_TRIGGERS",
 		},
 	}
-
 	if err := storDb.SetTPDestinations(dests); err != nil {
 		t.Error(err)
 	}