From b0d0a16b9c7f7ce677ce82a84a504b51022840fc Mon Sep 17 00:00:00 2001 From: TeoV Date: Tue, 25 Jun 2019 15:54:02 +0300 Subject: [PATCH] Add test for libdns.go --- agents/libdns_test.go | 271 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 270 insertions(+), 1 deletion(-) diff --git a/agents/libdns_test.go b/agents/libdns_test.go index bef6861e3..e6665054a 100644 --- a/agents/libdns_test.go +++ b/agents/libdns_test.go @@ -18,7 +18,14 @@ along with this program. If not, see package agents -import "testing" +import ( + "reflect" + "testing" + + "github.com/cgrates/cgrates/config" + "github.com/cgrates/cgrates/utils" + "github.com/cgrates/dns" +) func TestE164FromNAPTR(t *testing.T) { if e164, err := e164FromNAPTR("8.7.6.5.4.3.2.1.0.1.6.e164.arpa."); err != nil { @@ -27,3 +34,265 @@ func TestE164FromNAPTR(t *testing.T) { t.Errorf("received: <%s>", e164) } } + +func TestAppendDNSAnswerTypeNAPTR(t *testing.T) { + m := new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeNAPTR) + if err := appendDNSAnswer(m); err != nil { + t.Error(err) + } + if len(m.Answer) != 1 { + t.Fatalf("Unexpected number of Answers : %+v", len(m.Answer)) + } else if m.Answer[0].Header().Name != "3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa." { + t.Errorf("expecting: <3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.>, received: <%+v>", m.Answer[0].Header().Name) + } else if m.Answer[0].Header().Rrtype != 35 { + t.Errorf("expecting: <35>, received: <%+v>", m.Answer[0].Header().Rrtype) + } else if m.Answer[0].Header().Class != dns.ClassINET { + t.Errorf("expecting: <%+v>, received: <%+v>", dns.ClassINET, m.Answer[0].Header().Rrtype) + } else if m.Answer[0].Header().Ttl != 60 { + t.Errorf("expecting: <60>, received: <%+v>", m.Answer[0].Header().Rrtype) + } +} + +func TestAppendDNSAnswerTypeA(t *testing.T) { + m := new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeA) + if err := appendDNSAnswer(m); err != nil { + t.Error(err) + } + if len(m.Answer) != 1 { + t.Fatalf("Unexpected number of Answers : %+v", len(m.Answer)) + } else if m.Answer[0].Header().Name != "3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa." { + t.Errorf("expecting: <3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.>, received: <%+v>", m.Answer[0].Header().Name) + } else if m.Answer[0].Header().Rrtype != 1 { + t.Errorf("expecting: <1>, received: <%+v>", m.Answer[0].Header().Rrtype) + } else if m.Answer[0].Header().Class != dns.ClassINET { + t.Errorf("expecting: <%+v>, received: <%+v>", dns.ClassINET, m.Answer[0].Header().Rrtype) + } else if m.Answer[0].Header().Ttl != 60 { + t.Errorf("expecting: <60>, received: <%+v>", m.Answer[0].Header().Rrtype) + } +} + +func TestAppendDNSAnswerUnexpectedType(t *testing.T) { + m := new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeAFSDB) + if err := appendDNSAnswer(m); err == nil || err.Error() != "unsupported DNS type: <18>" { + t.Error(err) + } +} + +func TestDNSDPFieldAsInterface(t *testing.T) { + m := new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeNAPTR) + dp := newDNSDataProvider(m, nil) + expected := m.Question[0] + if data, err := dp.FieldAsInterface([]string{"test"}); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(data, expected) { + t.Errorf("expecting: <%+v>, received: <%+v>", expected, data) + } +} + +func TestDNSDPFieldAsInterfaceEmptyPath(t *testing.T) { + m := new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeNAPTR) + dp := newDNSDataProvider(m, nil) + if _, err := dp.FieldAsInterface([]string{}); err == nil || + err.Error() != "empty field path" { + t.Error(err) + } +} + +func TestDNSDPFieldAsInterfaceFromCache(t *testing.T) { + m := new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeNAPTR) + dp := newDNSDataProvider(m, nil) + expected := m.Question[0] + if data, err := dp.FieldAsInterface([]string{"test"}); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(data, expected) { + t.Errorf("expecting: <%+v>, received: <%+v>", expected, data) + } + if data, err := dp.FieldAsInterface([]string{"test"}); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(data, expected) { + t.Errorf("expecting: <%+v>, received: <%+v>", expected, data) + } +} + +func TestDNSDPFieldAsString(t *testing.T) { + m := new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeNAPTR) + dp := newDNSDataProvider(m, nil) + expected := utils.ToJSON(m.Question[0]) + if data, err := dp.FieldAsString([]string{"test"}); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(data, expected) { + t.Errorf("expecting: <%+v>, received: <%+v>", expected, data) + } +} + +func TestDNSDPFieldAsStringEmptyPath(t *testing.T) { + m := new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeNAPTR) + dp := newDNSDataProvider(m, nil) + if _, err := dp.FieldAsString([]string{}); err == nil || + err.Error() != "empty field path" { + t.Error(err) + } +} + +func TestDNSDPFieldAsStringFromCache(t *testing.T) { + m := new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeNAPTR) + dp := newDNSDataProvider(m, nil) + expected := utils.ToJSON(m.Question[0]) + if data, err := dp.FieldAsString([]string{"test"}); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(data, expected) { + t.Errorf("expecting: <%+v>, received: <%+v>", expected, data) + } + if data, err := dp.FieldAsString([]string{"test"}); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(data, expected) { + t.Errorf("expecting: <%+v>, received: <%+v>", expected, data) + } +} + +func TestUpdateDNSMsgFromNM(t *testing.T) { + m := new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeNAPTR) + + nM := config.NewNavigableMap(nil) + itm := &config.NMItem{ + Path: []string{}, + Data: "Val1", + } + nM.Set([]string{"Path"}, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != "empty path in config item" { + t.Error(err) + } + + nM = config.NewNavigableMap(nil) + nM.Set([]string{"Path"}, "test", true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != `cannot cast val: "test" into []*config.NMItem` { + t.Error(err) + } + + nM = config.NewNavigableMap(nil) + itm = &config.NMItem{ + Path: []string{utils.Rcode}, + Data: 10, + } + nM.Set(itm.Path, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err != nil { + t.Error(err) + } + if m.Rcode != 10 { + t.Errorf("expecting: <10>, received: <%+v>", m.Rcode) + } + + nM = config.NewNavigableMap(nil) + itm = &config.NMItem{ + Path: []string{utils.Rcode}, + Data: "RandomValue", + } + nM.Set(itm.Path, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != `item: , err: strconv.ParseInt: parsing "RandomValue": invalid syntax` { + t.Error(err) + } + + nM = config.NewNavigableMap(nil) + itm = &config.NMItem{ + Path: []string{utils.Order}, + Data: "RandomValue", + } + nM.Set(itm.Path, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != `item: , err: strconv.ParseInt: parsing "RandomValue": invalid syntax` { + t.Error(err) + } + + nM = config.NewNavigableMap(nil) + itm = &config.NMItem{ + Path: []string{utils.Preference}, + Data: "RandomValue", + } + nM.Set(itm.Path, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != `item: , err: strconv.ParseInt: parsing "RandomValue": invalid syntax` { + t.Error(err) + } + + m = new(dns.Msg) + m.SetQuestion("3.6.9.4.7.1.7.1.5.6.8.9.4.e164.arpa.", dns.TypeA) + nM = config.NewNavigableMap(nil) + itm = &config.NMItem{ + Path: []string{utils.Order}, + Data: 10, + } + nM.Set(itm.Path, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != `field only works with NAPTR` { + t.Error(err) + } + + nM = config.NewNavigableMap(nil) + itm = &config.NMItem{ + Path: []string{utils.Preference}, + Data: 10, + } + nM.Set(itm.Path, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != `field only works with NAPTR` { + t.Error(err) + } + + nM = config.NewNavigableMap(nil) + itm = &config.NMItem{ + Path: []string{utils.Flags}, + Data: 10, + } + nM.Set(itm.Path, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != `field only works with NAPTR` { + t.Error(err) + } + + nM = config.NewNavigableMap(nil) + itm = &config.NMItem{ + Path: []string{utils.Service}, + Data: 10, + } + nM.Set(itm.Path, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != `field only works with NAPTR` { + t.Error(err) + } + + nM = config.NewNavigableMap(nil) + itm = &config.NMItem{ + Path: []string{utils.Regexp}, + Data: 10, + } + nM.Set(itm.Path, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != `field only works with NAPTR` { + t.Error(err) + } + + nM = config.NewNavigableMap(nil) + itm = &config.NMItem{ + Path: []string{utils.Replacement}, + Data: 10, + } + nM.Set(itm.Path, []*config.NMItem{itm}, true, true) + if err := updateDNSMsgFromNM(m, nM); err == nil || + err.Error() != `field only works with NAPTR` { + t.Error(err) + } + +}