From 48b571a1995ccab9270df66a7669609c299b315f Mon Sep 17 00:00:00 2001 From: gezimbll Date: Wed, 26 Oct 2022 10:56:45 -0400 Subject: [PATCH] improving coverage tests at config&engine --- config/datadbcfg_test.go | 49 ++++++--------- config/erscfg_test.go | 119 +++++++++++++++++++++++++++++------ config/objdp_test.go | 6 ++ config/rpcconn_test.go | 12 ++-- config/stordbcfg_test.go | 32 +++++----- engine/units_counter_test.go | 109 ++++++++++++++++++++++++++++++++ utils/reflect.go | 3 + utils/reflect_test.go | 4 -- utils/stringset_test.go | 4 ++ 9 files changed, 261 insertions(+), 77 deletions(-) diff --git a/config/datadbcfg_test.go b/config/datadbcfg_test.go index 664435fd2..e9c2d9ad3 100644 --- a/config/datadbcfg_test.go +++ b/config/datadbcfg_test.go @@ -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) } diff --git a/config/erscfg_test.go b/config/erscfg_test.go index e677838f3..91eb254f9 100644 --- a/config/erscfg_test.go +++ b/config/erscfg_test.go @@ -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", }, }, }, diff --git a/config/objdp_test.go b/config/objdp_test.go index c6ab221d8..4a3a8cee1 100644 --- a/config/objdp_test.go +++ b/config/objdp_test.go @@ -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) } } diff --git a/config/rpcconn_test.go b/config/rpcconn_test.go index cf49af93a..9a4d0bb29 100644 --- a/config/rpcconn_test.go +++ b/config/rpcconn_test.go @@ -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, }, diff --git a/config/stordbcfg_test.go b/config/stordbcfg_test.go index 925cf86ac..e10dda541 100644 --- a/config/stordbcfg_test.go +++ b/config/stordbcfg_test.go @@ -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 { + } } diff --git a/engine/units_counter_test.go b/engine/units_counter_test.go index 273505626..9e3b37732 100644 --- a/engine/units_counter_test.go +++ b/engine/units_counter_test.go @@ -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) + } +} diff --git a/utils/reflect.go b/utils/reflect.go index 5dcec2bd5..8751a1181 100644 --- a/utils/reflect.go +++ b/utils/reflect.go @@ -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 { diff --git a/utils/reflect_test.go b/utils/reflect_test.go index f08d8707b..c34fb3f1e 100644 --- a/utils/reflect_test.go +++ b/utils/reflect_test.go @@ -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) - } } diff --git a/utils/stringset_test.go b/utils/stringset_test.go index 99d24ffb6..da3036582 100644 --- a/utils/stringset_test.go +++ b/utils/stringset_test.go @@ -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)