uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 18:16:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

improving coverage tests at config&engine

Browse Source
This commit is contained in:
gezimbll
2022-10-26 10:56:45 -04:00
committed by Dan Christian Bogos
parent 0737c55898
commit 48b571a199
9 changed files with 261 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
config/datadbcfg_test.go
View File

@@ -97,57 +97,46 @@ func TestDataDbCfgloadFromJsonCfg(t *testing.T) {
if err := jsnCfg.dataDbCfg.Opts.loadFromJSONCfg(nil); err != nil {
t.Error(err)
}
jsonCfg = &DbJsonCfg{
} else if err := jsnCfg.dataDbCfg.loadFromJSONCfg(&DbJsonCfg{
Opts: &DBOptsJson{
RedisClusterSync: utils.StringPointer("test"),
},
}
if err := jsnCfg.dataDbCfg.loadFromJSONCfg(jsonCfg); err == nil {
}}); err == nil {
t.Error(err)
}
jsonCfg = &DbJsonCfg{
} else if err := jsnCfg.dataDbCfg.loadFromJSONCfg(&DbJsonCfg{
Opts: &DBOptsJson{
RedisClusterOndownDelay: utils.StringPointer("test2"),
},
}
if err := jsnCfg.dataDbCfg.loadFromJSONCfg(jsonCfg); err == nil {
}); err == nil {
t.Error(err)
}
jsonCfg = &DbJsonCfg{
} else if err := jsnCfg.dataDbCfg.loadFromJSONCfg(&DbJsonCfg{
Opts: &DBOptsJson{
RedisConnectTimeout: utils.StringPointer("test3"),
},
}
if err := jsnCfg.dataDbCfg.loadFromJSONCfg(jsonCfg); err == nil {
}); err == nil {
t.Error(err)
}
jsonCfg = &DbJsonCfg{
} else if err := jsnCfg.dataDbCfg.loadFromJSONCfg(&DbJsonCfg{
Opts: &DBOptsJson{
RedisReadTimeout: utils.StringPointer("test4"),
},
}
if err := jsnCfg.dataDbCfg.loadFromJSONCfg(jsonCfg); err == nil {
}); err == nil {
t.Error(err)
}
jsonCfg = &DbJsonCfg{
} else if err := jsnCfg.dataDbCfg.loadFromJSONCfg(&DbJsonCfg{
Opts: &DBOptsJson{
RedisWriteTimeout: utils.StringPointer("test4"),
RedisWriteTimeout: utils.StringPointer("test5"),
},
}
if err := jsnCfg.dataDbCfg.loadFromJSONCfg(jsonCfg); err == nil {
}); err == nil {
t.Error(err)
}
jsonCfg = &DbJsonCfg{
} else if err := jsnCfg.dataDbCfg.loadFromJSONCfg(&DbJsonCfg{
Opts: &DBOptsJson{
MongoQueryTimeout: utils.StringPointer("test4"),
},
}
if err := jsnCfg.dataDbCfg.loadFromJSONCfg(jsonCfg); err == nil {
}); err == nil {
t.Error(err)
} else if err := jsnCfg.dataDbCfg.loadFromJSONCfg(&DbJsonCfg{
Items: &map[string]*ItemOptJson{
utils.MetaAccounts: {
Ttl: utils.StringPointer("test5"),
}}}); err == nil {
t.Error(err)
}

119
config/erscfg_test.go
View File

@@ -965,6 +965,48 @@ func TestERSCfgAsMapInterfaceCase2(t *testing.T) {
"amqpExchangeProcessed":"amqprocess",
"amqpExchangeTypeProcessed":"amqtype",
"amqpRoutingKeyProcessed":"routekey",
"partialPath":"optpath",
"partialcsvFieldSeparator":",",
"kafkaTopic":"topic",
"kafkaMaxWait":"1m",
"kafkaTopicProcessed":"process",
"sqlDBName":"db",
"sqlTableName":"table",
"pgSSLMode":"pg",
"sqlDBNameProcessed":"dbname",
"sqlTableNameProcessed":"tablename",
"pgSSLModeProcessed":"sslprocess",
"awsRegion":"eu",
"awsKey":"key",
"awsSecret":"secret",
"awsToken":"token",
"awsRegionProcessed":"awsRegion",
"awsKeyProcessed":"keyprocess",
"awsSecretProcessed":"secretkey",
"awsTokenProcessed": "tokenprocess",
"sqsQueueID":"sqs",
"sqsQueueIDProcessed":"sqsid",
"s3BucketID":"s3bucket",
"s3FolderPathProcessed": "s3folder",
"s3BucketIDProcessed":"s3bucketid",
"natsJetStream":true,
"natsConsumerName": "NATConsumer",
"natsQueueID":"NATid",
"natsJWTFile":"jwt",
"natsCertificateAuthority":"auth",
"natsClientCertificate":"certificate",
"natsSeedFile":"seed",
"natsClientKey":"clientkey",
"natsJetStreamMaxWait":"1m",
"natsJetStreamProcessed":false,
"natsSubjectProcessed":"NATProcess",
"natsJWTFileProcessed":"jwtfile",
"natsSeedFileProcessed":"NATSeed",
"natsCertificateAuthorityProcessed":"CertificateAuth",
"natsClientCertificateProcessed":"ClientCertificate",
"natsClientKeyProcessed":"ClientKey",
"natsJetStreamMaxWaitProcessed":"1m",
},
},
],
@@ -1039,24 +1081,65 @@ func TestERSCfgAsMapInterfaceCase2(t *testing.T) {
utils.TenantCfg: "~*req.Destination1",
utils.TimezoneCfg: "",
utils.OptsCfg: map[string]interface{}{
utils.CSVLazyQuotes: false,
utils.KafkaGroupID: "test",
utils.CSVFieldSepOpt: ",",
utils.XMLRootPathOpt: "",
"csvHeaderDefineChar": ":",
"csvRowLength": 0,
"partialOrderField": "~*req.AnswerTime",
"partialCacheAction": utils.MetaNone,
"natsSubject": "cgrates_cdrs",
utils.AMQPQueueID: "id",
utils.AMQPQueueIDProcessedCfg: "queue",
utils.AMQPConsumerTag: "tag",
utils.AMQPExchange: "exchange",
utils.AMQPExchangeType: "type",
utils.AMQPRoutingKey: "key",
utils.AMQPExchangeProcessedCfg: "amqprocess",
utils.AMQPExchangeTypeProcessedCfg: "amqtype",
utils.AMQPRoutingKeyProcessedCfg: "routekey",
utils.CSVLazyQuotes: false,
utils.KafkaGroupID: "test",
utils.CSVFieldSepOpt: ",",
utils.XMLRootPathOpt: "",
"csvHeaderDefineChar": ":",
"csvRowLength": 0,
"partialOrderField": "~*req.AnswerTime",
"partialCacheAction": utils.MetaNone,
"natsSubject": "cgrates_cdrs",
utils.AMQPQueueID: "id",
utils.AMQPQueueIDProcessedCfg: "queue",
utils.AMQPConsumerTag: "tag",
utils.AMQPExchange: "exchange",
utils.AMQPExchangeType: "type",
utils.AMQPRoutingKey: "key",
utils.AMQPExchangeProcessedCfg: "amqprocess",
utils.AMQPExchangeTypeProcessedCfg: "amqtype",
utils.AMQPRoutingKeyProcessedCfg: "routekey",
utils.PartialPathOpt: "optpath",
utils.PartialCSVFieldSepartorOpt: ",",
utils.KafkaTopic: "topic",
utils.KafkaMaxWait: "1m0s",
utils.KafkaTopicProcessedCfg: "process",
utils.SQLDBNameOpt: "db",
utils.SQLTableNameOpt: "table",
utils.PgSSLModeCfg: "pg",
utils.SQLDBNameProcessedCfg: "dbname",
utils.SQLTableNameProcessedCfg: "tablename",
utils.PgSSLModeProcessedCfg: "sslprocess",
utils.AWSRegion: "eu",
utils.AWSKey: "key",
utils.AWSSecret: "secret",
utils.AWSToken: "token",
utils.AWSRegionProcessedCfg: "awsRegion",
utils.AWSKeyProcessedCfg: "keyprocess",
utils.AWSSecretProcessedCfg: "secretkey",
utils.AWSTokenProcessedCfg: "tokenprocess",
utils.SQSQueueID: "sqs",
utils.SQSQueueIDProcessedCfg: "sqsid",
utils.S3Bucket: "s3bucket",
utils.S3FolderPathProcessedCfg: "s3folder",
utils.S3BucketIDProcessedCfg: "s3bucketid",
utils.NatsJetStream: true,
utils.NatsConsumerName: "NATConsumer",
utils.NatsQueueID: "NATid",
utils.NatsJWTFile: "jwt",
utils.NatsSeedFile: "seed",
utils.NatsCertificateAuthority: "auth",
utils.NatsClientCertificate: "certificate",
utils.NatsClientKey: "clientkey",
utils.NatsJetStreamMaxWait: "1m0s",
utils.NATSJetStreamProcessedCfg: false,
utils.NATSSubjectProcessedCfg: "NATProcess",
utils.NATSJWTFileProcessedCfg: "jwtfile",
utils.NATSSeedFileProcessedCfg: "NATSeed",
utils.NATSCertificateAuthorityProcessedCfg: "CertificateAuth",
utils.NATSClientCertificateProcessed: "ClientCertificate",
utils.NATSClientKeyProcessedCfg: "ClientKey",
utils.NATSJetStreamMaxWaitProcessedCfg: "1m0s",
},
},
},

6
config/objdp_test.go
View File

@@ -53,11 +53,17 @@ func TestFieldAsInterfaceObjDPSliceOfInt(t *testing.T) {
obj: []int{12, 13},
cache: make(map[string]interface{}),
}
objDp2 := &ObjectDP{
obj: []interface{}{},
cache: make(map[string]interface{}),
}
expected := 13
if received, err := objDp.FieldAsInterface(object); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(received, expected) {
t.Errorf("Expected %+v, received %+v", expected, received)
} else if _, err = objDp2.FieldAsInterface([]string{"test"}); err != utils.ErrNotFound {
t.Error(err)
}
}

12
config/rpcconn_test.go
View File

@@ -53,9 +53,7 @@ func TestRPCConnsloadFromJsonCfgCase1(t *testing.T) {
PoolSize: 0,
Conns: []*RemoteHost{{
Address: "127.0.0.1:2014",
Transport: rpcclient.BiRPCJSON,
},
},
Transport: rpcclient.BiRPCJSON}},
},
utils.MetaInternal: {
Strategy: utils.MetaFirst,
@@ -105,8 +103,7 @@ func TestRPCConnsloadFromJsonCfgCase1(t *testing.T) {
t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(expected), utils.ToJSON(jsonCfg.rpcConns))
}
cfgJson := &RemoteHostJson{
Connect_timeout: utils.StringPointer("test"),
}
Connect_timeout: utils.StringPointer("test")}
if err := jsonCfg.rpcConns[utils.MetaLocalHost].Conns[0].loadFromJSONCfg(cfgJson); err == nil {
t.Error(err)
}
@@ -132,8 +129,7 @@ func TestRPCConnsloadFromJsonCfgCase2(t *testing.T) {
Conns: []*RemoteHost{{
Address: "127.0.0.1:2014",
Transport: rpcclient.BiRPCJSON,
},
},
}},
},
utils.MetaInternal: {
Strategy: utils.MetaFirst,
@@ -273,7 +269,7 @@ func TestRpcConnAsMapInterface1(t *testing.T) {
"rpc_conns": {
"*localhost": {
"conns": [
{"address": "127.0.0.1:2018", "tls": true, "synchronous": true, "transport": "*json",},
{"address": "127.0.0.1:2018", "tls": true, "synchronous": true, "transport": "*json"},
],
"poolSize": 2,
},

32
config/stordbcfg_test.go
View File

@@ -100,25 +100,23 @@ func TestStoreDbCfgloadFromJsonCfgCase1(t *testing.T) {
t.Errorf("Expected %+v \n, recevied %+v", utils.ToJSON(expected.RmtConns), utils.ToJSON(jsonCfg.storDbCfg.RmtConns))
}
var dbOpts *StorDBOpts
var jsonDbOpts *DBOptsJson
dbOpts.loadFromJSONCfg(jsonDbOpts)
if reflect.DeepEqual(nil, dbOpts) {
t.Error("expected nil")
}
jsonDOpts := &DBOptsJson{
SQLConnMaxLifetime: utils.StringPointer("test"),
}
if err := jsonCfg.storDbCfg.Opts.loadFromJSONCfg(jsonDOpts); err == nil {
if err := jsonCfg.storDbCfg.Opts.loadFromJSONCfg(nil); err != nil {
t.Error(err)
}
jjsonDOpts := &DBOptsJson{
MongoQueryTimeout: utils.StringPointer("test"),
}
if err := jsonCfg.storDbCfg.Opts.loadFromJSONCfg(jjsonDOpts); err == nil {
} else if err := jsonCfg.storDbCfg.Opts.loadFromJSONCfg(&DBOptsJson{
SQLConnMaxLifetime: utils.StringPointer("test1"),
}); err == nil {
t.Error(err)
} else if err := jsonCfg.storDbCfg.Opts.loadFromJSONCfg(&DBOptsJson{
MongoQueryTimeout: utils.StringPointer("test2"),
}); err == nil {
t.Error(err)
} else if err := jsonCfg.storDbCfg.loadFromJSONCfg(&DbJsonCfg{
Items: &map[string]*ItemOptJson{
utils.MetaSessionsCosts: {
Ttl: utils.StringPointer("test3"),
},
}}); err == nil {
}
}

109
engine/units_counter_test.go
View File

@@ -798,3 +798,112 @@ func TestUnitsCounterresetCounters(t *testing.T) {
t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", utils.ToJSON(exp), utils.ToJSON(ucs["kind"]))
}
}
func TestUnitCounterFieldAsInterface1(t *testing.T) {
uc := &UnitCounter{}
fldPath := make([]string, 0)
if _, err := uc.FieldAsInterface(fldPath); err == nil {
t.Error(err)
}
uc = &UnitCounter{
Counters: CounterFilters{
{
Value: 3,
Filter: &BalanceFilter{},
}}}
fldPath = []string{utils.Counters}
if _, err := uc.FieldAsInterface(fldPath); err != nil {
t.Error(err)
} else if _, err := uc.FieldAsInterface(append(fldPath, "second")); err == nil {
t.Error(err)
} else if _, err := uc.FieldAsInterface(append(fldPath, "1", "2")); err == nil {
t.Error(err)
}
uc.Counters = append(uc.Counters, &CounterFilter{
Value: 4,
Filter: &BalanceFilter{}},
)
if val, err := uc.FieldAsInterface(append(fldPath, "1")); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(val, uc.Counters[1]) {
t.Errorf("expected %v but got %v", utils.ToJSON(val), utils.ToJSON(uc.Counters[1]))
} else if _, err := uc.FieldAsInterface(append(fldPath, "1", "2")); err == nil {
t.Error(err)
}
}
func TestUnitCounterFieldAsInterface2(t *testing.T) {
uc := &UnitCounter{
CounterType: "balance",
Counters: CounterFilters{
&CounterFilter{
Value: 20.68,
Filter: &BalanceFilter{
Uuid: utils.StringPointer("uuid"),
ID: utils.StringPointer("id"),
Type: utils.StringPointer("type"),
Value: &utils.ValueFormula{
Method: "method",
Static: 25.0,
}}}},
}
fldPath := []string{utils.CounterType}
if val, err := uc.FieldAsInterface(fldPath); err != nil {
t.Error(err)
} else if val != uc.CounterType {
t.Errorf("expected %v , received %v ", val, uc.CounterType)
} else if _, err = uc.FieldAsInterface(append(fldPath, "2")); err == nil {
t.Error(err)
}
}
func TestUnitCounterFieldAsInterface3(t *testing.T) {
fldPath := []string{"test"}
uc := &UnitCounter{
CounterType: "balance",
Counters: CounterFilters{
&CounterFilter{
Value: 20.68,
Filter: &BalanceFilter{
Uuid: utils.StringPointer("uuid"),
ID: utils.StringPointer("id"),
Type: utils.StringPointer("type"),
Value: &utils.ValueFormula{
Method: "method",
Static: 25.0,
}}}},
}
if _, err := uc.FieldAsInterface(fldPath); err == nil {
t.Error(err)
} else if _, err = uc.FieldAsInterface([]string{"Counters[3]"}); err == nil {
t.Error(err)
} else if val, err := uc.FieldAsInterface([]string{"Counters[0]"}); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(val, uc.Counters[0]) {
t.Errorf("expected %v ,received %v", utils.ToJSON(val), utils.ToJSON(uc.Counters[0]))
} else if _, err = uc.FieldAsInterface([]string{"Counters[0]", utils.CounterType}); err == nil {
t.Error(err)
}
}
func TestUnitCounterFieldAsString(t *testing.T) {
fldPath := []string{}
uc := &UnitCounter{
CounterType: "event",
Counters: CounterFilters{
&CounterFilter{
Value: 20,
Filter: &BalanceFilter{
ID: utils.StringPointer("testID2"),
Type: utils.StringPointer("kind"),
Weight: utils.Float64Pointer(15),
}}},
}
if _, err := uc.FieldAsString(fldPath); err == nil {
t.Error(err)
} else if _, err := uc.FieldAsString([]string{utils.Counters}); err != nil {
t.Error(err)
}
}

3
utils/reflect.go
View File

@@ -678,6 +678,9 @@ func Difference(tm string, items ...interface{}) (diff interface{}, err error) {
}
items[i] = diff
return Difference(tm, items[i:]...)
} else {
fmt.Println(err)
}
if itmVal, err := IfaceAsDuration(item); err != nil {

4
utils/reflect_test.go
View File

@@ -621,10 +621,6 @@ func TestDifference(t *testing.T) {
} else if diff != time.Date(2009, 11, 10, 22, 59, 40, 0, time.UTC) {
t.Errorf("Expecting: %+v, received: %+v", time.Date(2009, 11, 10, 22, 59, 40, 0, time.UTC), diff)
}
if _, err := Difference("time.Second", time.Date(2009, 11, 10, 22, 59, 40, 0, time.UTC), "20000000"); err != nil {
t.Errorf("%v", err)
}
}

4
utils/stringset_test.go
View File

@@ -313,6 +313,10 @@ func TestStringString(t *testing.T) {
if err := json.Unmarshal([]byte(rcv), &rcvAsMap); err != nil {
t.Error(err)
}
sort.Slice(rcvAsMap, func(i, j int) bool {
return rcvAsMap[i] < rcvAsMap[j]
})
rcv = ToJSON(rcvAsMap)
if rcv != exp {
t.Errorf("expected %v received %v", exp, rcv)