mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-15 21:29:52 +05:00
465 lines
12 KiB
Go
465 lines
12 KiB
Go
/*
|
|
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
|
|
Copyright (C) ITsysCOM GmbH
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
package engine
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/cgrates/birpc/context"
|
|
"github.com/cgrates/cgrates/utils"
|
|
"github.com/nyaruka/phonenumbers"
|
|
)
|
|
|
|
func TestDynamicDPnewDynamicDP(t *testing.T) {
|
|
|
|
expDDP := &dynamicDP{
|
|
resConns: []string{"conn1"},
|
|
stsConns: []string{"conn2"},
|
|
actsConns: []string{"conn3"},
|
|
tenant: "cgrates.org",
|
|
initialDP: utils.StringSet{
|
|
"test": struct{}{},
|
|
},
|
|
cache: utils.MapStorage{},
|
|
ctx: context.Background(),
|
|
}
|
|
|
|
if rcv := newDynamicDP(context.Background(), []string{"conn1"}, []string{"conn2"},
|
|
[]string{"conn3"}, "cgrates.org",
|
|
utils.StringSet{"test": struct{}{}}); !reflect.DeepEqual(rcv, expDDP) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(expDDP), utils.ToJSON(rcv))
|
|
}
|
|
}
|
|
|
|
func TestDynamicDPString(t *testing.T) {
|
|
|
|
rcv := &dynamicDP{
|
|
resConns: []string{"conn1"},
|
|
stsConns: []string{"conn2"},
|
|
actsConns: []string{"conn3"},
|
|
tenant: "cgrates.org",
|
|
initialDP: utils.StringSet{
|
|
"test": struct{}{},
|
|
},
|
|
cache: utils.MapStorage{},
|
|
ctx: context.Background(),
|
|
}
|
|
exp2 := "[\"test\"]"
|
|
rcv2 := rcv.String()
|
|
if !reflect.DeepEqual(rcv2, exp2) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(exp2), utils.ToJSON(rcv2))
|
|
}
|
|
}
|
|
|
|
func TestDynamicDPFieldAsInterfaceErrFilename(t *testing.T) {
|
|
|
|
rcv := &dynamicDP{
|
|
resConns: []string{"conn1"},
|
|
stsConns: []string{"conn2"},
|
|
actsConns: []string{"conn3"},
|
|
tenant: "cgrates.org",
|
|
initialDP: utils.StringSet{
|
|
"test": struct{}{},
|
|
},
|
|
cache: utils.MapStorage{},
|
|
ctx: context.Background(),
|
|
}
|
|
_, err := rcv.FieldAsInterface([]string{""})
|
|
if err == nil || err.Error() != "invalid fieldname <[]>" {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>",
|
|
"invalid fieldname <[]>", err)
|
|
}
|
|
}
|
|
|
|
func TestDynamicDPFieldAsInterfaceErrLenFldPath(t *testing.T) {
|
|
|
|
rcv := &dynamicDP{
|
|
resConns: []string{"conn1"},
|
|
stsConns: []string{"conn2"},
|
|
actsConns: []string{"conn3"},
|
|
tenant: "cgrates.org",
|
|
initialDP: utils.StringSet{
|
|
"test": struct{}{},
|
|
},
|
|
cache: utils.MapStorage{},
|
|
ctx: context.Background(),
|
|
}
|
|
_, err := rcv.FieldAsInterface([]string{})
|
|
if err == nil || err != utils.ErrNotFound {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>",
|
|
utils.ErrNotFound, err)
|
|
}
|
|
}
|
|
|
|
func TestDynamicDPFieldAsInterface(t *testing.T) {
|
|
|
|
DDP := &dynamicDP{
|
|
resConns: []string{"conn1"},
|
|
stsConns: []string{"conn2"},
|
|
actsConns: []string{"conn3"},
|
|
tenant: "cgrates.org",
|
|
initialDP: utils.StringSet{
|
|
"test": struct{}{},
|
|
},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
},
|
|
ctx: context.Background(),
|
|
}
|
|
result, err := DDP.FieldAsInterface([]string{"testField"})
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
exp := "testValue"
|
|
if !reflect.DeepEqual(result, exp) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(exp), utils.ToJSON(result))
|
|
}
|
|
}
|
|
|
|
func TestLibphonenumberDPString(t *testing.T) {
|
|
var pInt int32 = 2
|
|
LDP := &libphonenumberDP{
|
|
pNumber: &phonenumbers.PhoneNumber{
|
|
CountryCode: &pInt,
|
|
},
|
|
}
|
|
exp2 := "country_code:2 "
|
|
rcv2 := LDP.String()
|
|
if !reflect.DeepEqual(rcv2, exp2) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(exp2), utils.ToJSON(rcv2))
|
|
}
|
|
}
|
|
|
|
func TestLibphonenumberDPFieldAsString(t *testing.T) {
|
|
var pInt int32 = 2
|
|
LDP := &libphonenumberDP{
|
|
pNumber: &phonenumbers.PhoneNumber{
|
|
CountryCode: &pInt,
|
|
},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
},
|
|
}
|
|
exp2 := "testValue"
|
|
rcv2, err := LDP.FieldAsString([]string{"testField"})
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !reflect.DeepEqual(rcv2, exp2) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(exp2), utils.ToJSON(rcv2))
|
|
}
|
|
}
|
|
|
|
func TestLibphonenumberDPFieldAsStringError(t *testing.T) {
|
|
var pInt int32 = 2
|
|
LDP := &libphonenumberDP{
|
|
pNumber: &phonenumbers.PhoneNumber{
|
|
CountryCode: &pInt,
|
|
},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
},
|
|
}
|
|
_, err := LDP.FieldAsString([]string{"testField", "testField2"})
|
|
if err == nil || err.Error() != "WRONG_PATH" {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>",
|
|
"WRONG_PATH", err)
|
|
}
|
|
}
|
|
|
|
func TestLibphonenumberDPFieldAsInterfaceLen0(t *testing.T) {
|
|
var pInt int32 = 2
|
|
LDP := &libphonenumberDP{
|
|
pNumber: &phonenumbers.PhoneNumber{
|
|
CountryCode: &pInt,
|
|
},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
},
|
|
}
|
|
exp2 := &libphonenumberDP{
|
|
pNumber: &phonenumbers.PhoneNumber{
|
|
CountryCode: &pInt,
|
|
},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
}}
|
|
exp2.setDefaultFields()
|
|
|
|
rcv2, err := LDP.FieldAsInterface([]string{})
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !reflect.DeepEqual(rcv2, exp2.cache) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>",
|
|
exp2.cache, rcv2)
|
|
}
|
|
}
|
|
|
|
func TestNewLibPhoneNumberDPErr(t *testing.T) {
|
|
|
|
number := "badNum"
|
|
|
|
if _, err := newLibPhoneNumberDP(number); err != phonenumbers.ErrNotANumber {
|
|
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestNewLibPhoneNumberDP(t *testing.T) {
|
|
|
|
number := "+355123456789"
|
|
|
|
num, err := phonenumbers.ParseAndKeepRawInput(number, utils.EmptyString)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
exp := utils.DataProvider(&libphonenumberDP{pNumber: num, cache: make(utils.MapStorage)})
|
|
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if rcv, err := newLibPhoneNumberDP(number); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("Expected \n<%+v>, Received \n<%+v>", exp, rcv)
|
|
}
|
|
|
|
}
|
|
|
|
func TestFieldAsInterfacelibphonenumberDP(t *testing.T) {
|
|
|
|
dDP := &libphonenumberDP{
|
|
pNumber: &phonenumbers.PhoneNumber{},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
},
|
|
}
|
|
|
|
expErr := `invalid field path <[fld1 fld2 fld3]> for libphonenumberDP`
|
|
if _, err := dDP.FieldAsInterface([]string{"fld1", "fld2", "fld3"}); err.Error() != expErr {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
// unfinished do with buffer
|
|
func TestLibphonenumberDPfieldAsInterfaceGeoLocationErr(t *testing.T) {
|
|
|
|
dDP := &libphonenumberDP{
|
|
pNumber: &phonenumbers.PhoneNumber{},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
},
|
|
}
|
|
|
|
if rcv, err := dDP.fieldAsInterface([]string{"GeoLocation"}); err != nil {
|
|
t.Error(rcv, err)
|
|
}
|
|
}
|
|
|
|
// unfinished do with buffer
|
|
func TestLibphonenumberDPfieldAsInterfaceCarrierErr(t *testing.T) {
|
|
var pInt int32 = 49444444
|
|
var nNum uint64 = 49233333333333
|
|
dDP := &libphonenumberDP{
|
|
pNumber: &phonenumbers.PhoneNumber{
|
|
CountryCode: &pInt,
|
|
NationalNumber: &nNum,
|
|
},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
},
|
|
}
|
|
|
|
if rcv, err := dDP.fieldAsInterface([]string{"Carrier"}); err != nil {
|
|
t.Error(rcv, err)
|
|
}
|
|
}
|
|
|
|
func TestLibphonenumberDPfieldAsInterface(t *testing.T) {
|
|
|
|
var pInt int32 = 49
|
|
var nNum uint64 = 49
|
|
var leadingZeros int32 = 0
|
|
|
|
dDP := &libphonenumberDP{
|
|
pNumber: &phonenumbers.PhoneNumber{
|
|
CountryCode: &pInt,
|
|
NationalNumber: &nNum,
|
|
Extension: utils.StringPointer("+"),
|
|
RawInput: utils.StringPointer("+4917642092123"),
|
|
ItalianLeadingZero: utils.BoolPointer(true),
|
|
NumberOfLeadingZeros: &leadingZeros,
|
|
CountryCodeSource: phonenumbers.PhoneNumber_FROM_DEFAULT_COUNTRY.Enum(),
|
|
PreferredDomesticCarrierCode: utils.StringPointer("262 02"),
|
|
},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
},
|
|
}
|
|
|
|
exp := interface{}(pInt)
|
|
if rcv, err := dDP.fieldAsInterface([]string{"CountryCode"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
|
|
exp = interface{}(nNum)
|
|
if rcv, err := dDP.fieldAsInterface([]string{"NationalNumber"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
|
|
exp = interface{}("DE")
|
|
if rcv, err := dDP.fieldAsInterface([]string{"Region"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
exp = interface{}(phonenumbers.PhoneNumberType(11))
|
|
if rcv, err := dDP.fieldAsInterface([]string{"NumberType"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v><%t>", exp, rcv, rcv)
|
|
}
|
|
|
|
exp = interface{}("Deutschland")
|
|
if rcv, err := dDP.fieldAsInterface([]string{"GeoLocation"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
// exp = interface{}(nNum)
|
|
// if rcv, err := dDP.fieldAsInterface([]string{"Carrier"}); err != nil {
|
|
// t.Error(err)
|
|
// } else if rcv != exp {
|
|
// t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
// }
|
|
exp = interface{}(0)
|
|
if rcv, err := dDP.fieldAsInterface([]string{"LengthOfNationalDestinationCode"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
exp = interface{}("+4917642092123")
|
|
if rcv, err := dDP.fieldAsInterface([]string{"RawInput"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
exp = interface{}("+")
|
|
if rcv, err := dDP.fieldAsInterface([]string{"Extension"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
exp = interface{}(leadingZeros)
|
|
if rcv, err := dDP.fieldAsInterface([]string{"NumberOfLeadingZeros"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
exp = interface{}(true)
|
|
if rcv, err := dDP.fieldAsInterface([]string{"ItalianLeadingZero"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
exp = interface{}("262 02")
|
|
if rcv, err := dDP.fieldAsInterface([]string{"PreferredDomesticCarrierCode"}); err != nil {
|
|
t.Error(err)
|
|
} else if rcv != exp {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
exp = interface{}(phonenumbers.PhoneNumber_FROM_DEFAULT_COUNTRY)
|
|
if rcv, err := dDP.fieldAsInterface([]string{"CountryCodeSource"}); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("Expected <%+v>, Received <%v>", exp, rcv)
|
|
}
|
|
|
|
}
|
|
|
|
func TestDynamicDPfieldAsInterfaceMetaLibPhoneNumber(t *testing.T) {
|
|
|
|
dDP := &dynamicDP{
|
|
resConns: []string{"conn1"},
|
|
stsConns: []string{"conn2"},
|
|
actsConns: []string{"conn3"},
|
|
tenant: "cgrates.org",
|
|
initialDP: utils.StringSet{
|
|
"test": struct{}{},
|
|
},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
},
|
|
ctx: context.Background(),
|
|
}
|
|
|
|
dp, _ := newLibPhoneNumberDP("+4917642092123")
|
|
expAsField, _ := dp.FieldAsInterface([]string{})
|
|
exp := interface{}(expAsField)
|
|
if rcv, err := dDP.fieldAsInterface([]string{utils.MetaLibPhoneNumber, "+4917642092123"}); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("Expected \n<%v>, Received \n<%v>", exp, rcv)
|
|
}
|
|
}
|
|
|
|
func TestDynamicDPfieldAsInterfaceMetaLibPhoneNumberErr(t *testing.T) {
|
|
|
|
dDP := &dynamicDP{
|
|
resConns: []string{"conn1"},
|
|
stsConns: []string{"conn2"},
|
|
actsConns: []string{"conn3"},
|
|
tenant: "cgrates.org",
|
|
initialDP: utils.StringSet{
|
|
"test": struct{}{},
|
|
},
|
|
cache: utils.MapStorage{
|
|
"testField": "testValue",
|
|
},
|
|
ctx: context.Background(),
|
|
}
|
|
|
|
if _, err := dDP.fieldAsInterface([]string{utils.MetaLibPhoneNumber, "inexistentNum"}); err != phonenumbers.ErrNotANumber {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
// func TestDynamicDPfieldAsInterfaceNotFound(t *testing.T) {
|
|
// Cache.Clear(nil)
|
|
|
|
// ms := utils.MapStorage{}
|
|
// dDp := newDynamicDP(context.Background(), []string{}, []string{utils.ConcatenatedKey(utils.MetaInternal, utils.StatSConnsCfg)}, []string{}, "cgrates.org", ms)
|
|
// exp := ""
|
|
// if rcv, err := dDp.fieldAsInterface([]string{utils.MetaStats, "val", "val3"}); err == nil || err != utils.ErrNotFound {
|
|
// t.Error(err)
|
|
// } else if !reflect.DeepEqual(rcv, exp) {
|
|
// t.Errorf("Expected \n<%v>, Received \n<%v>", exp, rcv)
|
|
// }
|
|
// }
|