Add test for libdns.go

This commit is contained in:
TeoV
2019-06-25 15:54:02 +03:00
committed by Dan Christian Bogos
parent 12caccd278
commit b0d0a16b9c

View File

@@ -18,7 +18,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
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: <Rcode>, 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: <Order>, 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: <Preference>, 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 <Order> 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 <Preference> 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 <Flags> 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 <Service> 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 <Regexp> 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 <Replacement> only works with NAPTR` {
t.Error(err)
}
}