From b5358d1ceab38bd2ce2ab54f9cc2399624932ea6 Mon Sep 17 00:00:00 2001 From: NikolasPetriti Date: Fri, 7 Jul 2023 16:56:39 +0200 Subject: [PATCH] Add coverage tests for config --- config/diametercfg_test.go | 158 +++++++++++++++++++++++++++++ config/dispatchercfg_test.go | 81 ++++++++++----- config/dnsagentcfg_test.go | 188 +++++++++++++++++++++++++++++++++++ config/generalcfg_test.go | 78 +++++++++++++++ config/smconfig_test.go | 11 ++ config/stordbcfg_test.go | 41 ++++++++ 6 files changed, 532 insertions(+), 25 deletions(-) diff --git a/config/diametercfg_test.go b/config/diametercfg_test.go index cd291d112..46bb40bb5 100644 --- a/config/diametercfg_test.go +++ b/config/diametercfg_test.go @@ -117,4 +117,162 @@ func TestDiameterAgentCfgAsMapInterface(t *testing.T) { } } +func TestDiameterCfgloadFromJsonCfg(t *testing.T) { + strErr := "test`" + id := "t" + str := "test" + slc := []string{"val1", "val2"} + fcs := []*FcTemplateJsonCfg{{Value: &str}} + d := DiameterAgentCfg{ + RequestProcessors: []*RequestProcessor{ + { + ID: str, + }, + }, + } + + tests := []struct { + name string + js *DiameterAgentJsonCfg + sep string + exp string + }{ + { + name: "session conns", + js: &DiameterAgentJsonCfg{ + Sessions_conns: &[]string{"val1", "val2"}, + }, + sep: "", + exp: "", + }, + { + name: "Templates error", + js: &DiameterAgentJsonCfg{ + Templates: map[string][]*FcTemplateJsonCfg{"test": {{Value: &strErr}}}, + }, + sep: "", + exp: "Unclosed unspilit syntax", + }, + { + name: "Request processors", + js: &DiameterAgentJsonCfg{ + Request_processors: &[]*ReqProcessorJsnCfg{{ + ID: &id, + Filters: &slc, + Tenant: &str, + Timezone: &str, + Flags: &slc, + Request_fields: &fcs, + Reply_fields: &fcs, + }}, + }, + sep: "", + exp: "", + }, + { + name: "Request processors load data into one set", + js: &DiameterAgentJsonCfg{ + Request_processors: &[]*ReqProcessorJsnCfg{{ + ID: &str, + Filters: &slc, + Tenant: &str, + Timezone: &str, + Flags: &slc, + Request_fields: &fcs, + Reply_fields: &fcs, + }}, + }, + sep: "", + exp: "", + }, + { + name: "Request processors error", + js: &DiameterAgentJsonCfg{ + Request_processors: &[]*ReqProcessorJsnCfg{{ + ID: &str, + Filters: &slc, + Tenant: &strErr, + Timezone: &str, + Flags: &slc, + Request_fields: &fcs, + Reply_fields: &fcs, + }}, + }, + sep: "", + exp: "Unclosed unspilit syntax", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := d.loadFromJsonCfg(tt.js, tt.sep) + + if err != nil { + if err.Error() != tt.exp { + t.Fatal(err) + } + } + }) + } +} + +func TestDiameterAgentCfgAsMapInterface2(t *testing.T) { + str := "test" + slc := []string{"val1", "val2"} + bl := false + + ds := DiameterAgentCfg{ + Enabled: bl, + ListenNet: str, + Listen: str, + DictionariesPath: str, + SessionSConns: slc, + OriginHost: str, + OriginRealm: str, + VendorId: 1, + ProductName: str, + ConcurrentReqs: 1, + SyncedConnReqs: bl, + ASRTemplate: str, + Templates: map[string][]*FCTemplate{ + "test": {{Value: RSRParsers{{Rules: "test"}}}}, + }, + RequestProcessors: []*RequestProcessor{{}}, + } + + exp := map[string]any{ + utils.EnabledCfg: ds.Enabled, + utils.ListenNetCfg: ds.ListenNet, + utils.ListenCfg: ds.Listen, + utils.DictionariesPathCfg: ds.DictionariesPath, + utils.SessionSConnsCfg: slc, + utils.OriginHostCfg: ds.OriginHost, + utils.OriginRealmCfg: ds.OriginRealm, + utils.VendorIdCfg: ds.VendorId, + utils.ProductNameCfg: ds.ProductName, + utils.ConcurrentReqsCfg: ds.ConcurrentReqs, + utils.SyncedConnReqsCfg: ds.SyncedConnReqs, + utils.ASRTemplateCfg: ds.ASRTemplate, + utils.TemplatesCfg: map[string][]map[string]any{ + "test": {{"value": "test"}}, + }, + utils.RequestProcessorsCfg: []map[string]any{ + { + utils.IDCfg: "", + utils.TenantCfg: "", + utils.FiltersCfg: []string{}, + utils.FlagsCfg: map[string][]string{}, + utils.TimezoneCfgC: "", + utils.RequestFieldsCfg: []map[string]any{}, + utils.ReplyFieldsCfg: []map[string]any{}, + }, + }, + } + + rcv := ds.AsMapInterface("") + + if rcv == nil { + t.Errorf("recived %v, expected %v", rcv, exp) + } +} diff --git a/config/dispatchercfg_test.go b/config/dispatchercfg_test.go index 6039b49ac..ece33211b 100644 --- a/config/dispatchercfg_test.go +++ b/config/dispatchercfg_test.go @@ -137,34 +137,65 @@ func TestDispatcherSCfgAsMapInterface(t *testing.T) { } } -func TestDispatcherSCfgloadFromJsonCfg2(t *testing.T) { - d := DiameterAgentCfg{} +func TestDispatcherCfgloadFromJsonCfg(t *testing.T) { + bl := false + slc := []string{"val1", "val2"} - tests := []struct{ - name string - js *DiameterAgentJsonCfg - sep string - exp string - }{ - { - name: "session conns", - js: &DiameterAgentJsonCfg{ - Sessions_conns: &[]string{"val1", "val2"}, - }, - sep: "", - exp: "", - }, + d := DispatcherSCfg{} + + js := DispatcherSJsonCfg{ + Enabled: &bl, + Indexed_selects: &bl, + String_indexed_fields: &slc, + Prefix_indexed_fields: &slc, + Nested_fields: &bl, + Attributes_conns: &slc, } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - err := d.loadFromJsonCfg(tt.js, tt.sep) + exp := DispatcherSCfg{ + Enabled : bl, + IndexedSelects : bl, + StringIndexedFields : &slc, + PrefixIndexedFields : &slc, + AttributeSConns : slc, + NestedFields : bl, + } - if err != nil { - if err.Error() != tt.exp { - t.Fatal(err) - } - } - }) + err := d.loadFromJsonCfg(&js) + if err != nil { + t.Error(err) + } + + if !reflect.DeepEqual(d, exp) { + t.Errorf("received %v, expected %v", d, exp) + } +} + +func TestDispatcherSCfgAsMapInterface2(t *testing.T) { + bl := false + slc := []string{"val1", "val2"} + + dsp := DispatcherSCfg{ + Enabled : bl, + IndexedSelects : bl, + StringIndexedFields : &slc, + PrefixIndexedFields : &slc, + AttributeSConns : slc, + NestedFields : bl, + } + + exp := map[string]any{ + utils.EnabledCfg: bl, + utils.IndexedSelectsCfg: bl, + utils.StringIndexedFieldsCfg: slc, + utils.PrefixIndexedFieldsCfg: slc, + utils.AttributeSConnsCfg: slc, + utils.NestedFieldsCfg: bl, + } + + rcv := dsp.AsMapInterface() + + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("received %v, expected %v", rcv, exp) } } diff --git a/config/dnsagentcfg_test.go b/config/dnsagentcfg_test.go index 7affe095c..4accc9efd 100644 --- a/config/dnsagentcfg_test.go +++ b/config/dnsagentcfg_test.go @@ -192,3 +192,191 @@ func TestDNSAgentCfgAsMapInterface(t *testing.T) { } } + +func TestDNSAgentCfgloadFromJsonCfg2(t *testing.T) { + bl := false + str := "test" + slc := []string{"val1", "val2"} + eslc := []string{} + estr := "" + + da := DNSAgentCfg{ + RequestProcessors: []*RequestProcessor{{ + ID: str, + }}, + } + + js := DNSAgentJsonCfg{ + Enabled: &bl, + Listen: &str, + Listen_net: &str, + Sessions_conns: &slc, + Timezone: &str, + Request_processors: &[]*ReqProcessorJsnCfg{{ + ID: &str, + Filters: &slc, + Tenant: &estr, + Timezone: &str, + Flags: &eslc, + Request_fields: &[]*FcTemplateJsonCfg{}, + Reply_fields: &[]*FcTemplateJsonCfg{}, + }}, + } + + exp := DNSAgentCfg{ + Enabled: bl, + Listen: str, + ListenNet: str, + SessionSConns: slc, + Timezone: str, + RequestProcessors: []*RequestProcessor{{ + ID: str, + Tenant: RSRParsers{}, + Filters: slc, + Flags: utils.FlagsWithParams{}, + Timezone: str, + RequestFields: []*FCTemplate{}, + ReplyFields: []*FCTemplate{}, + }}, + } + + err := da.loadFromJsonCfg(&js, "") + if err != nil { + t.Fatal(err) + } + + if da.RequestProcessors == nil { + t.Errorf("received %v, expected %v", da, exp) + } +} + +func TestDNSAgentCfgloadFromJsonCfgError(t *testing.T) { + strErr := "test`" + da := DNSAgentCfg{} + + js := DNSAgentJsonCfg{ + Request_processors: &[]*ReqProcessorJsnCfg{ + { + Tenant: &strErr, + }, + }, + } + + err := da.loadFromJsonCfg(&js, "") + if err != nil { + t.Error(err) + } +} + +func TestDNSAgentCfgAsMapInterface2(t *testing.T) { + da := DNSAgentCfg{ + Enabled: false, + Listen: "test", + ListenNet: "test", + SessionSConns: []string{"val1", "val2"}, + Timezone: "test", + RequestProcessors: []*RequestProcessor{}, + } + + exp := map[string]any{ + utils.EnabledCfg: da.Enabled, + utils.ListenCfg: da.Listen, + utils.ListenNetCfg: da.ListenNet, + utils.SessionSConnsCfg: []string{"val1", "val2"}, + utils.TimezoneCfg: da.Timezone, + utils.RequestProcessorsCfg: []map[string]any{}, + } + + rcv := da.AsMapInterface("") + + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("received %v, expected %v", rcv, exp) + } +} + +func TestDNSAgentCfgloadFromJsonCfgRPErrors(t *testing.T) { + strErr := "test`" + type args struct { + js *ReqProcessorJsnCfg + sep string + } + + rp := RequestProcessor{} + + tests := []struct { + name string + args args + err string + }{ + { + name: "flags error", + args: args{js: &ReqProcessorJsnCfg{ + Flags: &[]string{"test:test:test:test"}, + }, sep: ""}, + err: utils.ErrUnsupportedFormat.Error(), + }, + { + name: "Request fields error", + args: args{js: &ReqProcessorJsnCfg{ + Request_fields: &[]*FcTemplateJsonCfg{ + { + Value: &strErr, + }, + }, + }, sep: ""}, + err: "Unclosed unspilit syntax", + }, + { + name: "Reply fields error", + args: args{js: &ReqProcessorJsnCfg{ + Reply_fields: &[]*FcTemplateJsonCfg{ + { + Value: &strErr, + }, + }, + }, sep: ""}, + err: "Unclosed unspilit syntax", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := rp.loadFromJsonCfg(tt.args.js, tt.args.sep) + + if err.Error() != tt.err { + t.Errorf("received %s, expected %s", err.Error(), tt.err) + } + }) + } +} + +func TestDNSAgentCfgAsMapInterfaceRP(t *testing.T) { + str := "test" + slc := []string{"val1", "val2"} + + rp := RequestProcessor{ + ID: str, + Tenant: RSRParsers{}, + Filters: slc, + Flags: utils.FlagsWithParams{}, + Timezone: str, + RequestFields: []*FCTemplate{{}}, + ReplyFields: []*FCTemplate{}, + } + + exp := map[string]any{ + utils.IDCfg: rp.ID, + utils.TenantCfg: "", + utils.FiltersCfg: rp.Filters, + utils.FlagsCfg: map[string][]string{}, + utils.TimezoneCfgC: rp.Timezone, + utils.RequestFieldsCfg: []map[string]any{{}}, + utils.ReplyFieldsCfg: []map[string]any{}, + } + + rcv := rp.AsMapInterface("") + + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("received %v, expected %v", rcv, exp) + } +} diff --git a/config/generalcfg_test.go b/config/generalcfg_test.go index e7f2eb299..3a6418109 100644 --- a/config/generalcfg_test.go +++ b/config/generalcfg_test.go @@ -168,3 +168,81 @@ func TestGeneralCfgAsMapInterface(t *testing.T) { t.Errorf("\nExpected: %+v\nReceived: %+v", utils.ToJSON(eMap), utils.ToJSON(rcv)) } } + +func TestGeneralCfgloadFromJsonCfg2(t *testing.T) { + id := "id" + g := GeneralCfg{} + + js := GeneralJsonCfg{ + Node_id: &id, + } + + err := g.loadFromJsonCfg(&js) + if err != nil { + t.Error(err) + } + + if g.NodeID != id { + t.Errorf("received %s", g.NodeID) + } +} + +func TestGeneralCfgloadFromJsonCfgErrors(t *testing.T) { + strErr := "test" + g := GeneralCfg{} + + tests := []struct{ + name string + arg *GeneralJsonCfg + err string + }{ + { + name: "Connect timeout error check", + arg: &GeneralJsonCfg{ + Connect_timeout: &strErr, + }, + err: `time: invalid duration "test"`, + }, + { + name: "Reply timeout error check", + arg: &GeneralJsonCfg{ + Reply_timeout: &strErr, + }, + err: `time: invalid duration "test"`, + }, + { + name: "Failed posts ttl error check", + arg: &GeneralJsonCfg{ + Failed_posts_ttl: &strErr, + }, + err: `time: invalid duration "test"`, + }, + { + name: "Locking timeout error check", + arg: &GeneralJsonCfg{ + Locking_timeout: &strErr, + }, + err: `time: invalid duration "test"`, + }, + } + + for _, tt := range tests { + err := g.loadFromJsonCfg(tt.arg) + + if err.Error() != tt.err { + t.Errorf("received %s, expecting %s", err, tt.err) + } + } +} + +func TestGeneralCfgAsMapInterface2(t *testing.T) { + g := GeneralCfg{ + LockingTimeout: 1 * time.Millisecond, + } + + rcv := g.AsMapInterface() + + if rcv["locking_timeout"] != "1ms" { + t.Errorf("received %s, expected %s", rcv["locking_timeout"], "1ms") + } +} diff --git a/config/smconfig_test.go b/config/smconfig_test.go index 62a86ef26..79912f379 100644 --- a/config/smconfig_test.go +++ b/config/smconfig_test.go @@ -623,3 +623,14 @@ func TestSessionSCfgAsMapInterface2(t *testing.T) { t.Errorf("expected %v, recived %v", exp, rcv) } } + +func TestSMConfigGetDefaultUsage(t *testing.T) { + s := SessionSCfg{} + + rcv := s.GetDefaultUsage("") + exp := s.DefaultUsage["*any"] + + if rcv != exp { + t.Errorf("received %v, expected %v", rcv, exp) + } +} \ No newline at end of file diff --git a/config/stordbcfg_test.go b/config/stordbcfg_test.go index eba06b9aa..aa20ed3e5 100644 --- a/config/stordbcfg_test.go +++ b/config/stordbcfg_test.go @@ -215,3 +215,44 @@ func TestStorDbCfgClone(t *testing.T) { t.Errorf("didn't clone, recived %v", rcv) } } + +func TestStoreDbCfgloadFromJsonCfgErrors(t *testing.T) { + strErr := "test" + + s := StorDbCfg{} + + tests := []struct { + name string + arg *DbJsonCfg + err string + }{ + { + name: "Query timeout error", + arg: &DbJsonCfg{ + Query_timeout: &strErr, + }, + err: `time: invalid duration "test"`, + }, + { + name: "Items error", + arg: &DbJsonCfg{ + Items: &map[string]*ItemOptJson{ + "test": { + Ttl: &strErr, + }, + }, + }, + err: `time: invalid duration "test"`, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := s.loadFromJsonCfg(tt.arg) + + if err.Error() != tt.err { + t.Errorf("received %s, expected %s", err, tt.err) + } + }) + } +}