From 19666594c899611ec673bfb78ce2686c297432e6 Mon Sep 17 00:00:00 2001 From: NikolasPetriti Date: Mon, 3 Jul 2023 16:54:21 +0200 Subject: [PATCH] Add coverage tests for apiercfg.go, smconfig.go, statscfg.go, stordbcfg.gp and supplierscfg.go --- config/apiercfg_test.go | 57 +++++++++++++++++++++++ config/smconfig_test.go | 70 ++++++++++++++++++++++++++++ config/statscfg_test.go | 88 +++++++++++++++++++++++++++++++++++ config/stordbcfg_test.go | 28 +++++++++++ config/supplierscfg_test.go | 92 +++++++++++++++++++++++++++++++++++++ 5 files changed, 335 insertions(+) diff --git a/config/apiercfg_test.go b/config/apiercfg_test.go index dd218d01e..a81607a8d 100644 --- a/config/apiercfg_test.go +++ b/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) + } +} diff --git a/config/smconfig_test.go b/config/smconfig_test.go index c877ed08b..62a86ef26 100644 --- a/config/smconfig_test.go +++ b/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) + } +} diff --git a/config/statscfg_test.go b/config/statscfg_test.go index fda8a0602..4364590b6 100644 --- a/config/statscfg_test.go +++ b/config/statscfg_test.go @@ -18,6 +18,7 @@ along with this program. If not, see 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) + } +} diff --git a/config/stordbcfg_test.go b/config/stordbcfg_test.go index 79e1c2297..eba06b9aa 100644 --- a/config/stordbcfg_test.go +++ b/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) + } +} diff --git a/config/supplierscfg_test.go b/config/supplierscfg_test.go index 4b3f783b7..33e61bd15 100644 --- a/config/supplierscfg_test.go +++ b/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) + } +}