Add coverage tests for config

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)
+	}
+}

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)
 	}
 }

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)
+	}
+}

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")
+	}
+}

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)
+	}
+}

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)
+			}
+		})
+	}
+}