Add coverage tests for config

config/config_json_test.go

@@ -1735,3 +1735,71 @@ func TestDfEventReaderCfg(t *testing.T) {
 		t.Errorf("Expected: %+v, \nreceived: %+v", utils.ToJSON(eCfg), utils.ToJSON(cfg))
 	}
 }
+
+func TestConfigJSONRPCConnJsonCfg(t *testing.T) {
+	jsn := &json.RawMessage{}
+	self := CgrJsonCfg{RPCConnsJsonName: jsn}
+
+	rcv, err := self.RPCConnJsonCfg()
+
+	if err != nil {
+		if err.Error() != "unexpected end of JSON input" {
+			t.Error(err)
+		}
+	}
+
+	if rcv != nil {
+		t.Error(rcv)
+	}
+}
+
+func TestConfigJSONCdreJsonCfgs(t *testing.T) {
+	jsn := &json.RawMessage{}
+	self := CgrJsonCfg{CDRE_JSN: jsn}
+
+	rcv, err := self.CdreJsonCfgs()
+
+	if err != nil {
+		if err.Error() != "unexpected end of JSON input" {
+			t.Error(err)
+		}
+	}
+
+	if rcv != nil {
+		t.Error(rcv)
+	}
+}
+
+func TestConfigJSONLoaderJsonCfg(t *testing.T) {
+	jsn := &json.RawMessage{}
+	self := CgrJsonCfg{LoaderJson: jsn}
+
+	rcv, err := self.LoaderJsonCfg()
+
+	if err != nil {
+		if err.Error() != "unexpected end of JSON input" {
+			t.Error(err)
+		}
+	}
+
+	if rcv != nil {
+		t.Error(rcv)
+	}
+}
+
+func TestConfigJSONLoaderCfgJson(t *testing.T) {
+	jsn := &json.RawMessage{}
+	self := CgrJsonCfg{CgrLoaderCfgJson: jsn}
+
+	rcv, err := self.LoaderCfgJson()
+
+	if err != nil {
+		if err.Error() != "unexpected end of JSON input" {
+			t.Error(err)
+		}
+	}
+
+	if rcv != nil {
+		t.Error(rcv)
+	}
+}

config/config_test.go

@@ -2684,3 +2684,157 @@ func TestConfigV1GetConfigSection(t *testing.T) {
 		})
 	}
 }
+
+func TestConfigAsMapInterface(t *testing.T) {
+	separator := ""
+	cfg := CGRConfig{
+		lks:             map[string]*sync.RWMutex{},
+		MaxCallDuration: 1 * time.Second,
+		DataFolderPath:  "test",
+		ConfigPath:      "test",
+		dfltCdreProfile: &CdreCfg{},
+		dfltEvRdr:       &EventReaderCfg{},
+		CdreProfiles: map[string]*CdreCfg{"test": {
+			ExportFormat:      "test",
+			ExportPath:        "test",
+			Filters:           []string{"test"},
+			Tenant:            "test",
+			AttributeSContext: "test",
+			Synchronous:       false,
+			Attempts:          1,
+			FieldSeparator:    'a',
+			Fields:            []*FCTemplate{},
+		}},
+		loaderCfg: LoaderSCfgs{{
+			Id:             "test",
+			Enabled:        true,
+			Tenant:         RSRParsers{},
+			DryRun:         false,
+			RunDelay:       1 * time.Second,
+			LockFileName:   "test",
+			CacheSConns:    []string{"test"},
+			FieldSeparator: "test",
+			TpInDir:        "test",
+			TpOutDir:       "test",
+			Data:           []*LoaderDataType{},
+		}},
+		httpAgentCfg: HttpAgentCfgs{{
+			ID:                "test",
+			Url:               "test",
+			SessionSConns:     []string{"test"},
+			RequestPayload:    "test",
+			ReplyPayload:      "test",
+			RequestProcessors: []*RequestProcessor{},
+		}},
+		ConfigReloads: map[string]chan struct{}{},
+		rldChans:      map[string]chan struct{}{},
+		rpcConns: map[string]*RPCConn{"test": {
+			Strategy: "test",
+			PoolSize: 1,
+			Conns:    []*RemoteHost{},
+		}},
+		generalCfg:       &GeneralCfg{},
+		dataDbCfg:        &DataDbCfg{},
+		storDbCfg:        &StorDbCfg{},
+		tlsCfg:           &TlsCfg{},
+		cacheCfg:         CacheCfg{},
+		listenCfg:        &ListenCfg{},
+		httpCfg:          &HTTPCfg{},
+		filterSCfg:       &FilterSCfg{},
+		ralsCfg:          &RalsCfg{},
+		schedulerCfg:     &SchedulerCfg{},
+		cdrsCfg:          &CdrsCfg{},
+		sessionSCfg:      &SessionSCfg{},
+		fsAgentCfg:       &FsAgentCfg{},
+		kamAgentCfg:      &KamAgentCfg{},
+		asteriskAgentCfg: &AsteriskAgentCfg{},
+		diameterAgentCfg: &DiameterAgentCfg{},
+		radiusAgentCfg:   &RadiusAgentCfg{},
+		dnsAgentCfg:      &DNSAgentCfg{},
+		attributeSCfg:    &AttributeSCfg{},
+		chargerSCfg:      &ChargerSCfg{},
+		resourceSCfg:     &ResourceSConfig{},
+		statsCfg:         &StatSCfg{},
+		thresholdSCfg:    &ThresholdSCfg{},
+		supplierSCfg:     &SupplierSCfg{},
+		sureTaxCfg:       &SureTaxCfg{},
+		dispatcherSCfg:   &DispatcherSCfg{},
+		loaderCgrCfg: &LoaderCgrCfg{
+			TpID:           "test",
+			DataPath:       "test",
+			DisableReverse: false,
+			FieldSeparator: 'a',
+			CachesConns:    []string{},
+			SchedulerConns: []string{},
+		},
+		migratorCgrCfg: &MigratorCgrCfg{},
+		mailerCfg:      &MailerCfg{},
+		analyzerSCfg:   &AnalyzerSCfg{},
+		apier:          &ApierCfg{},
+		ersCfg:         &ERsCfg{},
+	}
+
+	rcv := cfg.AsMapInterface(separator)
+	rpcConns := make(map[string]map[string]any, len(cfg.rpcConns))
+	for key, val := range cfg.rpcConns {
+		rpcConns[key] = val.AsMapInterface()
+	}
+
+	cdreProfiles := make(map[string]map[string]any)
+	for key, val := range cfg.CdreProfiles {
+		cdreProfiles[key] = val.AsMapInterface(separator)
+	}
+
+	loaderCfg := make([]map[string]any, len(cfg.loaderCfg))
+	for i, item := range cfg.loaderCfg {
+		loaderCfg[i] = item.AsMapInterface(separator)
+	}
+
+	httpAgentCfg := make([]map[string]any, len(cfg.httpAgentCfg))
+	for i, item := range cfg.httpAgentCfg {
+		httpAgentCfg[i] = item.AsMapInterface(separator)
+	}
+	exp := map[string]any{
+
+		utils.CdreProfiles:     cdreProfiles,
+		utils.LoaderCfg:        loaderCfg,
+		utils.HttpAgentCfg:     httpAgentCfg,
+		utils.RpcConns:         rpcConns,
+		utils.GeneralCfg:       cfg.generalCfg.AsMapInterface(),
+		utils.DataDbCfg:        cfg.dataDbCfg.AsMapInterface(),
+		utils.StorDbCfg:        cfg.storDbCfg.AsMapInterface(),
+		utils.TlsCfg:           cfg.tlsCfg.AsMapInterface(),
+		utils.CacheCfg:         cfg.cacheCfg.AsMapInterface(),
+		utils.ListenCfg:        cfg.listenCfg.AsMapInterface(),
+		utils.HttpCfg:          cfg.httpCfg.AsMapInterface(),
+		utils.FilterSCfg:       cfg.filterSCfg.AsMapInterface(),
+		utils.RalsCfg:          cfg.ralsCfg.AsMapInterface(),
+		utils.SchedulerCfg:     cfg.schedulerCfg.AsMapInterface(),
+		utils.CdrsCfg:          cfg.cdrsCfg.AsMapInterface(),
+		utils.SessionSCfg:      cfg.sessionSCfg.AsMapInterface(),
+		utils.FsAgentCfg:       cfg.fsAgentCfg.AsMapInterface(separator),
+		utils.KamAgentCfg:      cfg.kamAgentCfg.AsMapInterface(),
+		utils.AsteriskAgentCfg: cfg.asteriskAgentCfg.AsMapInterface(),
+		utils.DiameterAgentCfg: cfg.diameterAgentCfg.AsMapInterface(separator),
+		utils.RadiusAgentCfg:   cfg.radiusAgentCfg.AsMapInterface(separator),
+		utils.DnsAgentCfg:      cfg.dnsAgentCfg.AsMapInterface(separator),
+		utils.AttributeSCfg:    cfg.attributeSCfg.AsMapInterface(),
+		utils.ChargerSCfg:      cfg.chargerSCfg.AsMapInterface(),
+		utils.ResourceSCfg:     cfg.resourceSCfg.AsMapInterface(),
+		utils.StatsCfg:         cfg.statsCfg.AsMapInterface(),
+		utils.ThresholdSCfg:    cfg.thresholdSCfg.AsMapInterface(),
+		utils.SupplierSCfg:     cfg.supplierSCfg.AsMapInterface(),
+		utils.SureTaxCfg:       cfg.sureTaxCfg.AsMapInterface(separator),
+		utils.DispatcherSCfg:   cfg.dispatcherSCfg.AsMapInterface(),
+		utils.LoaderCgrCfg:     cfg.loaderCgrCfg.AsMapInterface(),
+		utils.MigratorCgrCfg:   cfg.migratorCgrCfg.AsMapInterface(),
+		utils.MailerCfg:        cfg.mailerCfg.AsMapInterface(),
+		utils.AnalyzerSCfg:     cfg.analyzerSCfg.AsMapInterface(),
+		utils.Apier:            cfg.apier.AsMapInterface(),
+		utils.ErsCfg:           cfg.ersCfg.AsMapInterface(separator),
+	}
+
+	if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("expected %v, received %v", exp, rcv)
+	}
+}

config/filterscfg_test.go

@@ -80,3 +80,45 @@ func TestFilterSCfgAsMapInterface(t *testing.T) {
 		t.Errorf("Expected: %+v ,\n received: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv))
 	}
 }
+
+func TestFilterSCfgloadFromJsonCfg2(t *testing.T) {
+	fSCfg := FilterSCfg{
+		StatSConns:     []string{},
+		ResourceSConns: []string{},
+	}
+	jsnCfg := &FilterSJsonCfg{
+		Stats_conns:     &[]string{utils.MetaInternal},
+		Resources_conns: &[]string{utils.MetaInternal},
+	}
+
+	err := fSCfg.loadFromJsonCfg(jsnCfg)
+	exp := FilterSCfg{
+		StatSConns:     []string{"*internal:*stats"},
+		ResourceSConns: []string{"*internal:*resources"},
+	}
+	if err != nil {
+		t.Error(err)
+	}
+
+	if !reflect.DeepEqual(exp, fSCfg) {
+		t.Errorf("expected %s, received %s", utils.ToJSON(exp), utils.ToJSON(fSCfg))
+	}
+
+	jsnCfg2 := &FilterSJsonCfg{
+		Stats_conns:     &[]string{utils.MetaInternal},
+		Resources_conns: &[]string{"test"},
+	}
+
+	err = fSCfg.loadFromJsonCfg(jsnCfg2)
+	exp = FilterSCfg{
+		StatSConns:     []string{"*internal:*stats"},
+		ResourceSConns: []string{"test"},
+	}
+	if err != nil {
+		t.Error(err)
+	}
+
+	if !reflect.DeepEqual(exp, fSCfg) {
+		t.Errorf("expected %s, received %s", utils.ToJSON(exp), utils.ToJSON(fSCfg))
+	}
+}

config/fwvdp_test.go

@@ -167,3 +167,20 @@ func TestFVWDPRemoteHost(t *testing.T) {
 		t.Error("didn't recive")
 	}
 }
+
+func TestFWVProviderFieldAsInterface(t *testing.T) {
+	fP := &FWVProvider{
+		req:   "test",
+		cache: utils.MapStorage{"test": 1},
+	}
+	fldPath := []string{"test"}
+
+	rcv, err := fP.FieldAsInterface(fldPath)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if rcv != 1 {
+		t.Error(rcv)
+	}
+}

config/rpcconn_test.go

@@ -56,3 +56,60 @@ func TestRPCConnsAsMapInterface(t *testing.T) {
 		t.Errorf("\nExpected: %+v\nReceived: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv))
 	}
 }
+
+func TestRPCConnloadFromJsonCfg(t *testing.T) {
+	str := "test"
+	str2 := "test2"
+	nm := 1
+	nm2 := 2
+	bl := false
+	rh := &RemoteHost{
+		ID:          str,
+		Address:     str,
+		Transport:   str,
+		Synchronous: true,
+		TLS:         true,
+	}
+	rC := &RPCConn{
+		Strategy: str,
+		PoolSize: nm,
+		Conns:    []*RemoteHost{rh},
+	}
+	jsnCfg := &RPCConnsJson{
+		Strategy: &str2,
+		PoolSize: &nm2,
+		Conns: &[]*RemoteHostJson{{
+			Id:          &str2,
+			Address:     &str2,
+			Transport:   &str2,
+			Synchronous: &bl,
+			Tls:         &bl,
+		}},
+	}
+
+	err := rC.loadFromJsonCfg(jsnCfg)
+	rh2 := &RemoteHost{
+		ID:          str2,
+		Address:     str2,
+		Transport:   str2,
+		Synchronous: false,
+		TLS:         false,
+	}
+	exp := &RPCConn{
+		Strategy: str2,
+		PoolSize: nm2,
+		Conns:    []*RemoteHost{rh2},
+	}
+	if err != nil {
+		t.Error(err)
+	}
+
+	if !reflect.DeepEqual(rC, exp) {
+		t.Errorf("expected %s, received %s", utils.ToJSON(exp), utils.ToJSON(rC))
+	}
+
+	err = rC.loadFromJsonCfg(nil)
+	if err != nil {
+		t.Error(err)
+	}
+}

config/rsrparser_test.go

@@ -311,3 +311,196 @@ func TestRSRParserParseDataProviderAsFloat64(t *testing.T) {
 		})
 	}
 }
+
+func TestRSRParserParseDataProvider(t *testing.T) {
+	prsr := RSRParser{
+		path: "test",
+	}
+	dP := &FWVProvider{
+		req:   "test",
+		cache: utils.MapStorage{"test": 1},
+	}
+
+	rcv, err := prsr.ParseDataProvider(dP, "")
+	if err != nil {
+		if err.Error() != "Invalid format for index : [t e s t]" {
+			t.Error(err)
+		}
+	} else {
+		t.Error("was expecting an error")
+	}
+
+	if rcv != "" {
+		t.Error(err)
+	}
+}
+
+func TestRSRParserParseDataProviderWithInterfaces(t *testing.T) {
+	prsr := RSRParser{
+		path: "test",
+	}
+	dP := &FWVProvider{
+		req:   "test",
+		cache: utils.MapStorage{"test": 1},
+	}
+
+	rcv, err := prsr.ParseDataProviderWithInterfaces(dP, "")
+	if err != nil {
+		if err.Error() != "Invalid format for index : [t e s t]" {
+			t.Error(err)
+		}
+	} else {
+		t.Error("was expecting an error")
+	}
+
+	if rcv != "" {
+		t.Error(err)
+	}
+}
+
+func TestRSRParserParseDataProviderAsFloat642(t *testing.T) {
+	prsr := RSRParser{
+		path: "test",
+	}
+	dP := &FWVProvider{
+		req:   "test",
+		cache: utils.MapStorage{"test": 1},
+	}
+
+	rcv, err := prsr.ParseDataProviderAsFloat64(dP, "")
+	if err != nil {
+		if err.Error() != "Invalid format for index : [t e s t]" {
+			t.Error(err)
+		}
+	} else {
+		t.Error("was expecting an error")
+	}
+
+	if rcv != 0.0 {
+		t.Error(err)
+	}
+}
+
+func TestRSRParsersParseValue(t *testing.T) {
+	str := "test"
+	prsrs := RSRParsers{{
+		Rules:           str,
+		AllFiltersMatch: false,
+		path:            str,
+		rsrRules:        []*utils.ReSearchReplace{},
+		converters:      utils.DataConverters{&utils.MultiplyConverter{Value: 1.2}},
+		filters:         utils.RSRFilters{},
+	}}
+
+	rcv, err := prsrs.ParseValue("test)")
+	if err != nil {
+		if err.Error() != `strconv.ParseFloat: parsing "test)": invalid syntax` {
+			t.Error(err)
+		}
+	} else {
+		t.Error("was expecting an error")
+	}
+
+	if rcv != "" {
+		t.Error(rcv)
+	}
+}
+
+func TestRSRParsersParseDataProvider(t *testing.T) {
+	str := "test"
+	prsrs := RSRParsers{{
+		Rules:           str,
+		AllFiltersMatch: false,
+		path:            str,
+		rsrRules:        []*utils.ReSearchReplace{},
+		converters:      utils.DataConverters{&utils.MultiplyConverter{Value: 1.2}},
+		filters:         utils.RSRFilters{},
+	}}
+	dP := &FWVProvider{
+		req:   "test",
+		cache: utils.MapStorage{"test": 1},
+	}
+
+	rcv, err := prsrs.ParseDataProvider(dP, "")
+	if err != nil {
+		if err.Error() != `Invalid format for index : [t e s t]` {
+			t.Error(err)
+		}
+	} else {
+		t.Error("was expecting an error")
+	}
+
+	if rcv != "" {
+		t.Error(rcv)
+	}
+}
+
+func TestRSRParsersParseDataProviderWithInterfaces(t *testing.T) {
+	str := "test"
+	prsrs := RSRParsers{{
+		Rules:           str,
+		AllFiltersMatch: false,
+		path:            str,
+		rsrRules:        []*utils.ReSearchReplace{},
+		converters:      utils.DataConverters{&utils.MultiplyConverter{Value: 1.2}},
+		filters:         utils.RSRFilters{},
+	}}
+	dP := &FWVProvider{
+		req:   "test",
+		cache: utils.MapStorage{"test": 1},
+	}
+
+	rcv, err := prsrs.ParseDataProviderWithInterfaces(dP, "")
+	if err != nil {
+		if err.Error() != `Invalid format for index : [t e s t]` {
+			t.Error(err)
+		}
+	} else {
+		t.Error("was expecting an error")
+	}
+
+	if rcv != "" {
+		t.Error(rcv)
+	}
+}
+
+func TestRSRParsersCompile2(t *testing.T) {
+	str := "test)"
+	prsrs := RSRParsers{{
+		Rules:           str,
+		AllFiltersMatch: false,
+		path:            str,
+		rsrRules:        []*utils.ReSearchReplace{},
+		converters:      utils.DataConverters{&utils.MultiplyConverter{Value: 1.2}},
+		filters:         utils.RSRFilters{},
+	}}
+
+	err := prsrs.Compile()
+
+	if err != nil {
+		if err.Error() != "invalid RSRFilter start rule in string: <test)>" {
+			t.Error(err)
+		}
+	} else {
+		t.Error("was expecting an error")
+	}
+}
+
+func TestRSRParserparseValue(t *testing.T) {
+	str := "test)"
+	prsr := RSRParser{
+		Rules:           str,
+		AllFiltersMatch: false,
+		path:            str,
+		rsrRules: []*utils.ReSearchReplace{{
+			ReplaceTemplate: "test",
+			Matched:         true,
+		},
+		}}
+
+	rcv := prsr.RegexpMatched()
+
+	if rcv != true {
+		t.Error(rcv)
+	}
+}