Add coverage tests for config

config/loaderscfg_test.go

@@ -20,6 +20,7 @@ package config
 import (
 	"fmt"
 	"reflect"
+	"strings"
 	"testing"
 
 	"github.com/cgrates/cgrates/utils"
@@ -271,3 +272,60 @@ func TestLoadersCFGLoadFromJsonCfg(t *testing.T) {
 		})
 	}
 }
+
+func TestLoaderSCfgloadFromJsonCfg2(t *testing.T) {
+	str := "test)"
+	self := &LoaderSCfg{}
+	jsnCfg := &LoaderJsonCfg{
+		Tenant: &str,
+	}
+
+	err := self.loadFromJsonCfg(jsnCfg, "")
+
+	if err != nil {
+		if err.Error() != "invalid RSRFilter start rule in string: <)>" {
+			t.Error(err)
+		}
+	}
+
+	jsnCfg2 := &LoaderJsonCfg{
+		Caches_conns: &[]string{str},
+	}
+
+	err = self.loadFromJsonCfg(jsnCfg2, "")
+	if err != nil {
+		t.Error(err)
+	}
+
+	if self.CacheSConns[0] != str {
+		t.Error(self.CacheSConns[0])
+	}
+}
+
+func TestLoaderSCfgAsMapInterface(t *testing.T) {
+	l := &LoaderSCfg{
+		Tenant: RSRParsers{{
+			Rules:           "test",
+			AllFiltersMatch: true,
+		}},
+	}
+
+	exp := map[string]any{
+		utils.TenantCfg:         strings.Join([]string{"test"}, utils.EmptyString),
+		utils.IdCfg:             l.Id,
+		utils.EnabledCfg:        l.Enabled,
+		utils.DryRunCfg:         l.DryRun,
+		utils.RunDelayCfg:       "0",
+		utils.LockFileNameCfg:   l.LockFileName,
+		utils.CacheSConnsCfg:    []string{},
+		utils.FieldSeparatorCfg: l.FieldSeparator,
+		utils.TpInDirCfg:        l.TpInDir,
+		utils.TpOutDirCfg:       l.TpOutDir,
+		utils.DataCfg:           []map[string]any{},
+	}
+	rcv := l.AsMapInterface("")
+
+	if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("\nexpeting: %s\n received: %s\n", utils.ToJSON(exp), utils.ToJSON(rcv))
+	}
+}

config/migratorcfg_test.go

@@ -174,3 +174,26 @@ func TestMigratorCgrCfgAsMapInterface(t *testing.T) {
 	}
 
 }
+
+func TestMigratorCgrCfgloadFromJsonCfg2(t *testing.T) {
+	str := "*test"
+	mg := &MigratorCgrCfg{}
+	jsnCfg := &MigratorCfgJson{
+		Out_dataDB_type: &str,
+		Out_storDB_type: &str,
+	}
+
+	err := mg.loadFromJsonCfg(jsnCfg)
+	if err != nil {
+		t.Error(err)
+	}
+
+	exp := &MigratorCgrCfg{
+		OutDataDBType: str,
+		OutStorDBType: str,
+	}
+
+	if !reflect.DeepEqual(exp, mg) {
+		t.Errorf("\nexpected: %s \nreceived: %s\n", utils.ToJSON(exp), utils.ToJSON(mg))
+	}
+}

config/radiuscfg_test.go

@@ -114,3 +114,146 @@ func TestRadiusAgentCfgAsMapInterface(t *testing.T) {
 		t.Errorf("\nExpected: %+v\nReceived: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv))
 	}
 }
+
+func TestRadiusAgentCfgloadFromJsonCfg2(t *testing.T) {
+	str := "test"
+	str2 := "test)"
+	self := &RadiusAgentCfg{
+		RequestProcessors: []*RequestProcessor{{
+			ID: str,
+		}},
+	}
+	jsnCfg := &RadiusAgentJsonCfg{
+		Sessions_conns: &[]string{str},
+		Request_processors: &[]*ReqProcessorJsnCfg{{
+			ID:       &str,
+			Filters:  &[]string{str},
+			Tenant:   &str,
+			Timezone: &str,
+			Flags:    &[]string{str},
+			Request_fields: &[]*FcTemplateJsonCfg{{
+				Tag:          &str,
+				Type:         &str,
+				Path:         &str,
+				Attribute_id: &str,
+				Filters:      &[]string{str},
+			}},
+			Reply_fields: &[]*FcTemplateJsonCfg{{
+				Tag:          &str,
+				Type:         &str,
+				Path:         &str,
+				Attribute_id: &str,
+				Filters:      &[]string{str},
+			}},
+		}, {
+			ID: &str2,
+		}},
+	}
+
+	err := self.loadFromJsonCfg(jsnCfg, "")
+	if err != nil {
+		t.Error(err)
+	}
+
+	jsnCfg2 := &RadiusAgentJsonCfg{
+		Sessions_conns: &[]string{str},
+		Request_processors: &[]*ReqProcessorJsnCfg{{
+			ID:       &str2,
+			Filters:  &[]string{str2},
+			Tenant:   &str2,
+			Timezone: &str2,
+			Flags:    &[]string{str2},
+			Request_fields: &[]*FcTemplateJsonCfg{{
+				Tag:          &str2,
+				Type:         &str2,
+				Path:         &str2,
+				Attribute_id: &str2,
+				Filters:      &[]string{"test)"},
+			}},
+			Reply_fields: &[]*FcTemplateJsonCfg{{
+				Tag:          &str2,
+				Type:         &str2,
+				Path:         &str2,
+				Attribute_id: &str2,
+				Filters:      &[]string{"test)"},
+			}},
+		}},
+	}
+
+	err = self.loadFromJsonCfg(jsnCfg2, "")
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestRadiusAgentCfgAsMapInterface2(t *testing.T) {
+	str := "test"
+	ra := &RadiusAgentCfg{
+		Enabled:            true,
+		ListenNet:          str,
+		ListenAuth:         str,
+		ListenAcct:         str,
+		ClientSecrets:      map[string]string{str: str},
+		ClientDictionaries: map[string]string{str: str},
+		SessionSConns:      []string{str},
+		RequestProcessors: []*RequestProcessor{
+			{
+				ID: str,
+				Tenant: RSRParsers{{
+					Rules:           "t",
+					AllFiltersMatch: true,
+				},
+					{
+						Rules:           "e",
+						AllFiltersMatch: true,
+					},
+					{
+						Rules:           "s",
+						AllFiltersMatch: true,
+					},
+					{
+						Rules:           "t",
+						AllFiltersMatch: true,
+					}},
+				Filters:  []string{str},
+				Flags:    utils.FlagsWithParams{str: {}},
+				Timezone: str,
+				RequestFields: []*FCTemplate{
+					{
+						AttributeID: str,
+						Tag:         str,
+						Type:        str,
+						Path:        str,
+						Filters:     []string{str},
+					},
+				},
+				ReplyFields: []*FCTemplate{
+					{
+						AttributeID: str,
+						Tag:         str,
+						Type:        str,
+						Path:        str,
+						Filters:     []string{str},
+					},
+				},
+			},
+		},
+	}
+
+	exp := map[string]any{
+		utils.EnabledCfg:            ra.Enabled,
+		utils.ListenNetCfg:          ra.ListenNet,
+		utils.ListenAuthCfg:         ra.ListenAuth,
+		utils.ListenAcctCfg:         ra.ListenAcct,
+		utils.ClientSecretsCfg:      map[string]any{str: str},
+		utils.ClientDictionariesCfg: map[string]any{str: str},
+		utils.SessionSConnsCfg:      []string{str},
+		utils.RequestProcessorsCfg:  []map[string]any{ra.RequestProcessors[0].AsMapInterface("")},
+	}
+
+	rcv := ra.AsMapInterface("")
+
+	if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("\nexpected %s: \nreceived %s\n", utils.ToJSON(exp), utils.ToJSON(rcv))
+	}
+}

config/ralscfg_test.go

@@ -132,3 +132,67 @@ func TestRalsCfgAsMapInterface(t *testing.T) {
 		t.Errorf("Expected: %+v ,\n received: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv))
 	}
 }
+
+func TestRalsCfgloadFromJsonCfg(t *testing.T) {
+	str := "test"
+	bl := false
+	nm := 1
+	ralsCfg := &RalsCfg{
+		MaxComputedUsage: map[string]time.Duration{str: 1 * time.Second},
+	}
+	jsnRALsCfg := &RalsJsonCfg{
+		Enabled:                    &bl,
+		Thresholds_conns:           &[]string{str},
+		Stats_conns:                &[]string{str},
+		CacheS_conns:               &[]string{str},
+		Rp_subject_prefix_matching: &bl,
+		Remove_expired:             &bl,
+		Max_computed_usage:         &map[string]string{str: str},
+		Max_increments:             &nm,
+		Balance_rating_subject:     &map[string]string{str: str},
+	}
+
+	err := ralsCfg.loadFromJsonCfg(jsnRALsCfg)
+
+	if err != nil {
+		if err.Error() != `time: invalid duration "test"` {
+			t.Error(err)
+		}
+	}
+
+	if ralsCfg.ThresholdSConns[0] != str {
+		t.Error(ralsCfg.ThresholdSConns[0])
+	}
+
+	if ralsCfg.StatSConns[0] != str {
+		t.Error(ralsCfg.StatSConns[0])
+	}
+
+	jsnRALsCfg2 := &RalsJsonCfg{
+		Enabled:                    &bl,
+		Thresholds_conns:           &[]string{utils.MetaInternal},
+		Stats_conns:                &[]string{utils.MetaInternal},
+		CacheS_conns:               &[]string{str},
+		Rp_subject_prefix_matching: &bl,
+		Remove_expired:             &bl,
+		Max_computed_usage:         &map[string]string{str: str},
+		Max_increments:             &nm,
+		Balance_rating_subject:     &map[string]string{str: str},
+	}
+
+	err = ralsCfg.loadFromJsonCfg(jsnRALsCfg2)
+
+	if err != nil {
+		if err.Error() != `time: invalid duration "test"` {
+			t.Error(err)
+		}
+	}
+
+	if ralsCfg.ThresholdSConns[0] != utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds) {
+		t.Error(ralsCfg.ThresholdSConns[0])
+	}
+
+	if ralsCfg.StatSConns[0] != utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStatS) {
+		t.Error(ralsCfg.StatSConns[0])
+	}
+}

config/smconfig_test.go

@@ -892,3 +892,50 @@ func TestSMConfigAsteriskConnCfgloadFromJsonCfg(t *testing.T) {
 		t.Error("didn't load")
 	}
 }
+
+func TestSMConfigAsteriskAgentCfgloadFromJsonCfg(t *testing.T) {
+	aCfg := &AsteriskAgentCfg{}
+	jsnCfg := &AsteriskAgentJsonCfg{
+		Sessions_conns: &[]string{"test"},
+	}
+
+	err := aCfg.loadFromJsonCfg(jsnCfg)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if aCfg.SessionSConns[0] != "test" {
+		t.Error("didn't load")
+	}
+}
+
+func TestSMConfigAsteriskAgentCfgAsMapInterface(t *testing.T) {
+	str := "test"
+	aCfg := &AsteriskAgentCfg{
+		Enabled:       false,
+		SessionSConns: []string{str},
+		CreateCDR:     false,
+		AsteriskConns: []*AsteriskConnCfg{
+			{
+				Alias:           str,
+				Address:         str,
+				User:            str,
+				Password:        str,
+				ConnectAttempts: 1,
+				Reconnects:      1,
+			},
+		},
+	}
+	exp := map[string]any{
+		utils.EnabledCfg:       aCfg.Enabled,
+		utils.SessionSConnsCfg: []string{str},
+		utils.CreateCDRCfg:     aCfg.CreateCDR,
+		utils.AsteriskConnsCfg: []map[string]any{aCfg.AsteriskConns[0].AsMapInterface()},
+	}
+
+	rcv := aCfg.AsMapInterface()
+
+	if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("expected %s, received %s", utils.ToJSON(exp), utils.ToJSON(rcv))
+	}
+}