Add coverage tests for apiercfg.go, smconfig.go, statscfg.go, stordbcfg.gp and supplierscfg.go

config/apiercfg_test.go

@@ -111,3 +111,60 @@ func TestApierCfgAsMapInterface(t *testing.T) {
 		t.Errorf("\nExpected: %+v\nReceived: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv))
 	}
 }
+
+func TestApierCfgloadFromJsonCfg2(t *testing.T) {
+	bl := true
+	slc := []string{"val1", "val2"}
+
+	a := ApierCfg{}
+
+	js := ApierJsonCfg{
+		Enabled:          &bl,
+		Caches_conns:     &slc,
+		Scheduler_conns:  &slc,
+		Attributes_conns: &slc,
+	}
+
+	exp := ApierCfg{
+		Enabled: bl,
+		CachesConns: slc,
+        SchedulerConns: slc,
+		AttributeSConns: slc,
+	}
+
+	err := a.loadFromJsonCfg(&js) 
+
+	if err != nil {
+		t.Fatal("was not expecting an error", err)
+	}
+
+	if !reflect.DeepEqual(a, exp) {
+		t.Errorf("recived %v, expected %v", a, exp)
+	}
+
+}
+
+func TestApierCfgAsMapInterface2(t *testing.T) {
+	bl := true
+	slc := []string{"val1", "val2"}
+
+	a := ApierCfg{
+		Enabled: bl,
+		CachesConns: slc,
+        SchedulerConns: slc,
+		AttributeSConns: slc,
+	}
+
+	exp := map[string]any{
+		utils.EnabledCfg:         a.Enabled,
+		utils.CachesConnsCfg:     slc,
+		utils.SchedulerConnsCfg:  slc,
+		utils.AttributeSConnsCfg: slc,
+	}
+
+	rcv := a.AsMapInterface() 
+
+	if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("recived %v, expected %v", rcv, exp)
+	}
+}

config/smconfig_test.go

@@ -553,3 +553,73 @@ func TestAsteriskConnCfgloadFromJsonCfg(t *testing.T) {
 		t.Errorf("Expected: %+v , received: %+v", utils.ToJSON(expected), utils.ToJSON(asconcfg))
 	}
 }
+
+func TestSessionSCfgAsMapInterface2(t *testing.T) {
+	bl := false
+	str := "test"
+	slc := []string{"val1"}
+	dr := 1 * time.Millisecond
+	drs := "1ms"
+	fl := 1.2
+	nm := 1
+
+	scfg := SessionSCfg{
+		Enabled:             bl,
+		ListenBijson:        str,
+		ChargerSConns:       slc,
+		RALsConns:           slc,
+		ResSConns:           slc,
+		ThreshSConns:        slc,
+		StatSConns:          slc,
+		SupplSConns:         slc,
+		AttrSConns:          slc,
+		CDRsConns:           slc,
+		ReplicationConns:    slc,
+		DebitInterval:       dr,
+		StoreSCosts:         bl,
+		SessionTTL:          dr,
+		SessionTTLMaxDelay:  &dr,
+		SessionTTLLastUsed:  &dr,
+		SessionTTLUsage:     &dr,
+		SessionTTLLastUsage: &dr,
+		SessionIndexes:      utils.StringMap{},
+		ClientProtocol:      fl,
+		ChannelSyncInterval: dr,
+		TerminateAttempts:   nm,
+		AlterableFields:     utils.StringSet{},
+		DefaultUsage:        map[string]time.Duration{},
+	}
+
+	exp := map[string]any{
+		utils.EnabledCfg:             scfg.Enabled,
+		utils.ListenBijsonCfg:        scfg.ListenBijson,
+		utils.ChargerSConnsCfg:       slc,
+		utils.RALsConnsCfg:           slc,
+		utils.ResSConnsCfg:           slc,
+		utils.ThreshSConnsCfg:        slc,
+		utils.StatSConnsCfg:          slc,
+		utils.SupplSConnsCfg:         slc,
+		utils.AttrSConnsCfg:          slc,
+		utils.CDRsConnsCfg:           slc,
+		utils.ReplicationConnsCfg:    scfg.ReplicationConns,
+		utils.DebitIntervalCfg:       drs,
+		utils.StoreSCostsCfg:         scfg.StoreSCosts,
+		utils.SessionTTLCfg:          drs,
+		utils.SessionTTLMaxDelayCfg:  drs,
+		utils.SessionTTLLastUsedCfg:  drs,
+		utils.SessionTTLUsageCfg:     drs,
+		utils.SessionTTLLastUsageCfg: drs,
+		utils.SessionIndexesCfg:      scfg.SessionIndexes.Slice(),
+		utils.ClientProtocolCfg:      scfg.ClientProtocol,
+		utils.ChannelSyncIntervalCfg: drs,
+		utils.TerminateAttemptsCfg:   scfg.TerminateAttempts,
+		utils.AlterableFieldsCfg:     scfg.AlterableFields.AsSlice(),
+		utils.DefaultUsageCfg:        map[string]any{},
+	}
+
+	rcv := scfg.AsMapInterface()
+
+	if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("expected %v, recived %v", exp, rcv)
+	}
+}

config/statscfg_test.go

@@ -18,6 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package config
 
 import (
+	"fmt"
 	"reflect"
 	"testing"
 	"time"
@@ -136,3 +137,90 @@ func TestStatSCfgAsMapInterface(t *testing.T) {
 		t.Errorf("\nExpected: %+v\nReceived: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv))
 	}
 }
+
+func TestStatSCfgloadFromJsonCfg2(t *testing.T) {
+	st := StatSCfg{}
+
+	bl := true
+	nm := 1
+	dr := "1ns"
+	slc := []string{"val1", "val2"}
+
+	js := StatServJsonCfg{
+		Enabled:                  &bl,
+		Indexed_selects:          &bl,
+		Store_interval:           &dr,
+		Store_uncompressed_limit: &nm,
+		Thresholds_conns:         &slc,
+		String_indexed_fields:    &slc,
+		Prefix_indexed_fields:    &slc,
+		Nested_fields:            &bl,
+	}
+
+	exp := StatSCfg{
+		Enabled:                true,
+		IndexedSelects:         true,
+		StoreInterval:          1 * time.Nanosecond,
+		StoreUncompressedLimit: 1,
+		ThresholdSConns:        slc,
+		StringIndexedFields:    &slc,
+		PrefixIndexedFields:    &slc,
+		NestedFields:           true,
+	}
+
+	err := st.loadFromJsonCfg(&js)
+
+	if err != nil {
+		t.Errorf("didn't expect an error: %s", err)
+	}
+
+	if !reflect.DeepEqual(st, exp) {
+		t.Errorf("expected %v, recived %v", exp, st)
+	}
+
+	t.Run("check error in parse duration with nanosecs", func(t *testing.T) {
+		str := "test"
+
+		js := StatServJsonCfg{
+			Store_interval: &str,
+		}
+
+		err := st.loadFromJsonCfg(&js)
+		exp := fmt.Errorf(`time: invalid duration "test"`)
+
+		if err.Error() != exp.Error() {
+			t.Errorf("recived %s, expected %s", err, exp)
+		}
+	})
+}
+
+func TestStatSCfgAsMapInterface2(t *testing.T) {
+
+	st := StatSCfg{
+		Enabled:                false,
+		IndexedSelects:         false,
+		StoreInterval:          1 * time.Second,
+		StoreUncompressedLimit: 1,
+		ThresholdSConns:        []string{"val1", "val2"},
+		StringIndexedFields:    &[]string{"val1", "val2"},
+		PrefixIndexedFields:    &[]string{"val1", "val2"},
+		NestedFields:           true,
+	}
+
+	exp := map[string]any{
+		utils.EnabledCfg:                st.Enabled,
+		utils.IndexedSelectsCfg:         st.IndexedSelects,
+		utils.StoreIntervalCfg:          "1s",
+		utils.StoreUncompressedLimitCfg: st.StoreUncompressedLimit,
+		utils.ThresholdSConnsCfg:        []string{"val1", "val2"},
+		utils.StringIndexedFieldsCfg:    []string{"val1", "val2"},
+		utils.PrefixIndexedFieldsCfg:    []string{"val1", "val2"},
+		utils.NestedFieldsCfg:           st.NestedFields,
+	}
+
+	rcv := st.AsMapInterface()
+
+	if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("recived %v, expected %v", rcv, exp)
+	}
+}

config/stordbcfg_test.go

@@ -20,6 +20,7 @@ package config
 import (
 	"reflect"
 	"testing"
+	"time"
 
 	"github.com/cgrates/cgrates/utils"
 )
@@ -187,3 +188,30 @@ func TestStorDbCfgAsMapInterface(t *testing.T) {
 		t.Errorf("Expected: %+v ,\n received: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv))
 	}
 }
+
+func TestStorDbCfgClone(t *testing.T) {
+	str := "test"
+	nm := 1
+	db := &StorDbCfg{
+		Type:                str,
+		Host:                str,
+		Port:                str,
+		Name:                str,
+		User:                str,
+		Password:            str,
+		MaxOpenConns:        nm,
+		MaxIdleConns:        nm,
+		ConnMaxLifetime:     nm,
+		StringIndexedFields: []string{"val1", "val2"},
+		PrefixIndexedFields: []string{"val3", "val4"},
+		QueryTimeout:        1 * time.Millisecond,
+		SSLMode:             str,
+		Items:               map[string]*ItemOpt{},
+	}
+
+	rcv := db.Clone()
+
+	if !reflect.DeepEqual(rcv, db) {
+		t.Errorf("didn't clone, recived %v", rcv)
+	}
+}

config/supplierscfg_test.go

@@ -135,3 +135,95 @@ func TestSupplierSCfgAsMapInterface(t *testing.T) {
 		t.Errorf("\nExpected: %+v\nReceived: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv))
 	}
 }
+
+func TestSupplierSCfgloadFromJsonCfg2(t *testing.T) {
+	slc := []string{"val1", "val2"}
+
+	spl := SupplierSCfg{
+		Enabled:             false,
+		IndexedSelects:      false,
+		StringIndexedFields: &slc,
+		PrefixIndexedFields: &slc,
+		AttributeSConns:     []string{"val1", "val2"},
+		ResourceSConns:      []string{"val1", "val2"},
+		StatSConns:          []string{"val1", "val2"},
+		RALsConns:           []string{"val1", "val2"},
+		DefaultRatio:        1,
+		NestedFields:        false,
+	}
+
+	bl := true
+	nm := 2
+	slc2 := []string{"val3", "val4"}
+
+	js := SupplierSJsonCfg{
+		Enabled:               &bl,
+		Indexed_selects:       &bl,
+		String_indexed_fields: &slc2,
+		Prefix_indexed_fields: &slc2,
+		Nested_fields:         &bl,
+		Attributes_conns:      &slc2,
+		Resources_conns:       &slc2,
+		Stats_conns:           &slc2,
+		Rals_conns:            &slc2,
+		Default_ratio:         &nm,
+	}
+
+	exp := SupplierSCfg{
+		Enabled:             true,
+		IndexedSelects:      true,
+		StringIndexedFields: &slc2,
+		PrefixIndexedFields: &slc2,
+		AttributeSConns:     []string{"val3", "val4"},
+		ResourceSConns:      []string{"val3", "val4"},
+		StatSConns:          []string{"val3", "val4"},
+		RALsConns:           []string{"val3", "val4"},
+		DefaultRatio:        2,
+		NestedFields:        true,
+	}
+
+	err := spl.loadFromJsonCfg(&js)
+
+	if err != nil {
+		t.Error("was not exoecting an error")
+	}
+
+	if !reflect.DeepEqual(spl, exp) {
+		t.Errorf("expected %v, recived %v", exp, spl)
+	}
+}
+
+func TestSupplierSCfgAsMapInterface2(t *testing.T) {
+	slc := []string{"val1", "val2"}
+
+	spl := SupplierSCfg{
+		Enabled:             true,
+		IndexedSelects:      true,
+		StringIndexedFields: &slc,
+		PrefixIndexedFields: &slc,
+		AttributeSConns:     []string{"val1", "val2"},
+		ResourceSConns:      []string{"val1", "val2"},
+		StatSConns:          []string{"val1", "val2"},
+		RALsConns:           []string{"val1", "val2"},
+		DefaultRatio:        1,
+		NestedFields:        false,
+	}
+
+	exp := map[string]any{
+		utils.EnabledCfg:             spl.Enabled,
+		utils.IndexedSelectsCfg:      spl.IndexedSelects,
+		utils.StringIndexedFieldsCfg: []string{"val1", "val2"},
+		utils.PrefixIndexedFieldsCfg: []string{"val1", "val2"},
+		utils.AttributeSConnsCfg:     []string{"val1", "val2"},
+		utils.ResourceSConnsCfg:      []string{"val1", "val2"},
+		utils.StatSConnsCfg:          []string{"val1", "val2"},
+		utils.DefaultRatioCfg:        spl.DefaultRatio,
+		utils.NestedFieldsCfg:        spl.NestedFields,
+	}
+
+	rcv := spl.AsMapInterface()
+
+	if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("expected %+v, recived %+v", exp, rcv)
+	}
+}