From 4d246d76972834fe388660ceacef5cfdfd268ff0 Mon Sep 17 00:00:00 2001 From: NikolasPetriti Date: Thu, 31 Aug 2023 16:54:51 +0200 Subject: [PATCH] Add coverage tests for config --- config/loaderscfg_test.go | 58 +++++++++++++++ config/migratorcfg_test.go | 23 ++++++ config/radiuscfg_test.go | 143 +++++++++++++++++++++++++++++++++++++ config/ralscfg_test.go | 64 +++++++++++++++++ config/smconfig_test.go | 47 ++++++++++++ 5 files changed, 335 insertions(+) diff --git a/config/loaderscfg_test.go b/config/loaderscfg_test.go index c2cf6cbbf..041a83e27 100644 --- a/config/loaderscfg_test.go +++ b/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)) + } +} diff --git a/config/migratorcfg_test.go b/config/migratorcfg_test.go index b9dedbf09..bdbd1c7e4 100644 --- a/config/migratorcfg_test.go +++ b/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)) + } +} diff --git a/config/radiuscfg_test.go b/config/radiuscfg_test.go index 956154eeb..50c2094af 100644 --- a/config/radiuscfg_test.go +++ b/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)) + } +} diff --git a/config/ralscfg_test.go b/config/ralscfg_test.go index 9d824536f..a9f023719 100644 --- a/config/ralscfg_test.go +++ b/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]) + } +} diff --git a/config/smconfig_test.go b/config/smconfig_test.go index 7ee22b2ea..844e0f0ae 100644 --- a/config/smconfig_test.go +++ b/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)) + } +}