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

Correcting integration tests replacing SMGEvent with the new engine.SafEvent

Browse Source
This commit is contained in:
DanB
2018-08-16 15:41:59 +02:00
parent db954c8406
commit d5784073da
7 changed files with 121 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
agents/dmtagent_it_test.go
View File

@@ -31,7 +31,6 @@ import (
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
"github.com/fiorix/go-diameter/diam"
"github.com/fiorix/go-diameter/diam/avp"
@@ -112,7 +111,7 @@ func TestDmtAgentCCRAsSMGenericEvent(t *testing.T) {
if ccr.diamMessage, err = ccr.AsDiameterMessage(); err != nil {
t.Error(err)
}
eSMGE := sessions.SMGenericEvent{"EventName": DIAMETER_CCR,
eSMGE := map[string]interface{}{"EventName": DIAMETER_CCR,
"OriginID": "routinga;1442095190;1476802709",
"Account": "*users", "Category": "call",
"AnswerTime": "2015-11-23 12:22:24 +0000 UTC",
@@ -147,7 +146,7 @@ func TestDmtAgentCCRAsSMGenericEvent(t *testing.T) {
&config.CfgCdrField{Tag: "Usage", FieldId: "Usage", Type: "*handler", HandlerId: "*ccr_usage", Mandatory: true},
&config.CfgCdrField{Tag: "SubscriberID", FieldId: "SubscriberId", Type: "*composed",
Value: utils.ParseRSRFieldsMustCompile("Subscription-Id>Subscription-Id-Data", utils.INFIELD_SEP), Mandatory: true}}
if smge, err := ccr.AsSMGenericEvent(ccrFields); err != nil {
if smge, err := ccr.AsMapIface(ccrFields); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(eSMGE, smge) {
t.Errorf("Expecting: %+v, received: %+v", eSMGE, smge)

3
apier/v1/smgenericv1_it_test.go
View File

@@ -30,7 +30,6 @@ import (
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
@@ -126,7 +125,7 @@ func TestSMGV1AccountsBefore(t *testing.T) {
// Make sure account was debited properly
func TestSMGV1GetMaxUsage(t *testing.T) {
setupReq := &sessions.SMGenericEvent{utils.RequestType: utils.META_PREPAID, utils.Tenant: "cgrates.org",
setupReq := map[string]interface{}{utils.RequestType: utils.META_PREPAID, utils.Tenant: "cgrates.org",
utils.Account: "1003", utils.Destination: "1002", utils.SetupTime: "2015-11-10T15:20:00Z"}
var maxTime float64
if err := smgV1Rpc.Call("SMGenericV1.GetMaxUsage", setupReq, &maxTime); err != nil {

7
general_tests/a1_it_test.go
View File

@@ -33,7 +33,6 @@ import (
"github.com/cgrates/cgrates/apier/v2"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
@@ -127,7 +126,7 @@ func TestA1itAddBalance1(t *testing.T) {
}
func TestA1itDataSession1(t *testing.T) {
smgEv := sessions.SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "INITIATE_SESSION",
utils.ToR: utils.DATA,
utils.OriginID: "504966119",
@@ -151,7 +150,7 @@ func TestA1itDataSession1(t *testing.T) {
} else if maxUsage != 10240 {
t.Error("Received: ", maxUsage)
}
smgEv = sessions.SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "UPDATE_SESSION",
utils.Account: "rpdata1",
utils.Category: "data1",
@@ -177,7 +176,7 @@ func TestA1itDataSession1(t *testing.T) {
} else if maxUsage != 2097152 {
t.Error("Bad max usage: ", maxUsage)
}
smgEv = sessions.SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TERMINATE_SESSION",
utils.Account: "rpdata1",
utils.Category: "data1",

45
sessions/data_it_test.go
View File

@@ -110,7 +110,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
} else if cc.Cost != 1024 {
t.Errorf("Calling Responder.GetCost got callcost: %v", cc.Cost)
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123491",
@@ -139,7 +139,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
t.Errorf("Expected: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.DATA].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123491",
@@ -167,7 +167,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
} else if acnt.BalanceMap[utils.DATA].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.DATA].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123491",
@@ -183,7 +183,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
utils.LastUsed: "0",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession",
if err := smgRPC.Call("SMGenericV1.TerminateSession",
smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
@@ -217,7 +217,7 @@ func TestSMGDataLastUsedMultipleUpdates(t *testing.T) {
} else if totalVal := acnt.BalanceMap[utils.DATA].GetTotalValue(); totalVal != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, totalVal)
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123492",
@@ -252,7 +252,7 @@ func TestSMGDataLastUsedMultipleUpdates(t *testing.T) {
aSessions[0].Usage != time.Duration(6144) {
t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123492",
@@ -286,7 +286,7 @@ func TestSMGDataLastUsedMultipleUpdates(t *testing.T) {
aSessions[0].Usage != time.Duration(15360) {
t.Errorf("wrong active sessions: %v", aSessions[0].Usage)
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123492",
@@ -320,7 +320,7 @@ func TestSMGDataLastUsedMultipleUpdates(t *testing.T) {
aSessions[0].Usage != time.Duration(13312) { // 14MB in used, 2MB extra reserved
t.Errorf("wrong active sessions: %+v", aSessions[0].Usage)
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123492",
@@ -353,7 +353,7 @@ func TestSMGDataLastUsedMultipleUpdates(t *testing.T) {
aSessions[0].Usage != time.Duration(14336) { // 14MB in use
t.Errorf("wrong active sessions: %v", aSessions[0].Usage)
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123492",
@@ -369,7 +369,7 @@ func TestSMGDataLastUsedMultipleUpdates(t *testing.T) {
utils.LastUsed: "0", // refund 1024 (extra used) + 1024 (extra reserved)
}
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
if err := smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 89088.000000
@@ -423,7 +423,7 @@ func TestSMGDataTTLExpired(t *testing.T) {
} else if totalVal := acnt.BalanceMap[utils.DATA].GetTotalValue(); totalVal != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, totalVal)
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "TestSMGDataTTLExpired",
@@ -482,7 +482,7 @@ func TestSMGDataTTLExpMultiUpdates(t *testing.T) {
} else if totalVal := acnt.BalanceMap[utils.DATA].GetTotalValue(); totalVal != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, totalVal)
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123495",
@@ -517,7 +517,7 @@ func TestSMGDataTTLExpMultiUpdates(t *testing.T) {
int64(aSessions[0].Usage) != 4096 {
t.Errorf("wrong active sessions: %d", int64(aSessions[0].Usage))
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123495",
@@ -580,7 +580,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
} else if totalVal := acnt.BalanceMap[utils.DATA].GetTotalValue(); totalVal != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, totalVal)
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123495",
@@ -615,7 +615,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
int64(aSessions[0].Usage) != 2048 {
t.Errorf("wrong active sessions usage: %d", int64(aSessions[0].Usage))
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123495",
@@ -652,7 +652,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
t.Errorf("wrong active sessions usage: %d", int64(aSessions[0].Usage))
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123495",
@@ -688,7 +688,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
int64(aSessions[0].Usage) != 1024 {
t.Errorf("wrong active sessions usage: %d", int64(aSessions[0].Usage))
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123495",
@@ -704,17 +704,20 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.LastUsed: "0",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
if err := smgRPC.Call("SMGenericV1.TerminateSession",
smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 101376.000000 // refunded last 1MB reserved and unused
if err := smgRPC.Call("ApierV2.GetAccount", acntAttrs, &acnt); err != nil {
t.Error(err)
} else if acnt.BalanceMap[utils.DATA].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.DATA].GetTotalValue())
t.Errorf("Expected: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.DATA].GetTotalValue())
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions",
nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
nil, &aSessions); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err, aSessions)
}
}
@@ -742,7 +745,7 @@ func TestSMGDataTTLUsageProtection(t *testing.T) {
} else if totalVal := acnt.BalanceMap[utils.DATA].GetTotalValue(); totalVal != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, totalVal)
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.DATA,
utils.OriginID: "123495",

129
sessions/smg_it_test.go
View File

@@ -92,7 +92,7 @@ func TestSMGVoiceTPFromFolder(t *testing.T) {
}
func TestSMGVoiceMonetaryRefund(t *testing.T) {
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123451",
@@ -123,7 +123,7 @@ func TestSMGVoiceMonetaryRefund(t *testing.T) {
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123451",
@@ -139,7 +139,7 @@ func TestSMGVoiceMonetaryRefund(t *testing.T) {
utils.Usage: "1m",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
if err := smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 8.8
@@ -151,7 +151,7 @@ func TestSMGVoiceMonetaryRefund(t *testing.T) {
}
func TestSMGVoiceVoiceRefund(t *testing.T) {
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123452",
@@ -183,7 +183,7 @@ func TestSMGVoiceVoiceRefund(t *testing.T) {
t.Errorf("Expected: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123452",
@@ -199,7 +199,7 @@ func TestSMGVoiceVoiceRefund(t *testing.T) {
utils.Usage: "1m",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
if err := smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 150.0 * float64(time.Second)
@@ -218,7 +218,7 @@ func TestSMGVoiceMixedRefund(t *testing.T) {
}
//t.Logf("Initial monetary: %f", acnt.BalanceMap[utils.MONETARY].GetTotalValue())
//t.Logf("Initial voice: %f", acnt.BalanceMap[utils.VOICE].GetTotalValue())
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123453",
@@ -248,9 +248,11 @@ func TestSMGVoiceMixedRefund(t *testing.T) {
t.Error(err)
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eVoiceVal ||
acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eMoneyVal {
t.Errorf("Expected: %f, received: %f, expetced money: %f, recieved money : %f", eVoiceVal, acnt.BalanceMap[utils.VOICE].GetTotalValue(), eMoneyVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
t.Errorf("Expected: %f, received: %f, expetced money: %f, recieved money : %f",
eVoiceVal, acnt.BalanceMap[utils.VOICE].GetTotalValue(),
eMoneyVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123453",
@@ -266,7 +268,8 @@ func TestSMGVoiceMixedRefund(t *testing.T) {
utils.Usage: "1m",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
if err := smgRPC.Call("SMGenericV1.TerminateSession",
smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eVoiceVal = 90.0 * float64(time.Second)
@@ -275,7 +278,9 @@ func TestSMGVoiceMixedRefund(t *testing.T) {
t.Error(err)
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eVoiceVal ||
acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eMoneyVal {
t.Errorf("Expected voice: %f, received voice : %f, expected money: %f, received money: %f", eVoiceVal, acnt.BalanceMap[utils.VOICE].GetTotalValue(), eMoneyVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
t.Errorf("Expected voice: %f, received voice : %f, expected money: %f, received money: %f",
eVoiceVal, acnt.BalanceMap[utils.VOICE].GetTotalValue(),
eMoneyVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
//t.Logf("After monetary: %f", acnt.BalanceMap[utils.MONETARY].GetTotalValue())
//t.Logf("After voice: %f", acnt.BalanceMap[utils.VOICE].GetTotalValue())
@@ -290,7 +295,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "12350",
@@ -318,7 +323,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "12350",
@@ -344,7 +349,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "12350",
@@ -370,7 +375,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "12350",
@@ -384,14 +389,16 @@ func TestSMGVoiceLastUsed(t *testing.T) {
utils.Usage: "1m",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
if err := smgRPC.Call("SMGenericV1.TerminateSession",
smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 7.59
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &acnt); err != nil {
t.Error(err)
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
t.Errorf("Expected: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
}
@@ -404,7 +411,7 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "1234911",
@@ -432,7 +439,7 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "1234911",
@@ -456,9 +463,10 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &acnt); err != nil {
t.Error(err)
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
t.Errorf("Expected: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "1234911",
@@ -472,14 +480,16 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
utils.LastUsed: "0s",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
if err := smgRPC.Call("SMGenericV1.TerminateSession",
smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 6.590000
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &acnt); err != nil {
t.Error(err)
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
t.Errorf("Expected: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
}
@@ -492,7 +502,7 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "1234922",
@@ -520,7 +530,7 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "1234922",
@@ -544,9 +554,10 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &acnt); err != nil {
t.Error(err)
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
t.Errorf("Expected: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "1234922",
@@ -560,14 +571,16 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
utils.LastUsed: "0s",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
if err := smgRPC.Call("SMGenericV1.TerminateSession",
smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 5.590000
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &acnt); err != nil {
t.Error(err)
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
t.Errorf("Expected: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
}
@@ -578,9 +591,10 @@ func TestSMGVoiceSessionTTL(t *testing.T) {
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &acnt); err != nil {
t.Error(err)
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
t.Errorf("Expected: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT_SESSION_TTL",
utils.ToR: utils.VOICE,
utils.OriginID: "12360",
@@ -618,7 +632,7 @@ func TestSMGVoiceSessionTTL(t *testing.T) {
} else if acnt.BalanceMap[utils.MONETARY].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT_SESSION_TTL",
utils.ToR: utils.VOICE,
utils.OriginID: "12360",
@@ -692,7 +706,7 @@ func TestSMGVoiceSessionTTLWithRelocate(t *testing.T) {
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eAcntVal {
t.Errorf("Expecting: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv := SMGenericEvent{
smgEv := engine.NewMapEvent(map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT_SESSION_TTL_RELOCATE",
utils.ToR: utils.VOICE,
utils.OriginID: "12361",
@@ -706,7 +720,7 @@ func TestSMGVoiceSessionTTLWithRelocate(t *testing.T) {
utils.SetupTime: "2016-01-05 18:30:49",
utils.AnswerTime: "2016-01-05 18:31:05",
utils.Usage: "2m",
}
})
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
@@ -717,7 +731,7 @@ func TestSMGVoiceSessionTTLWithRelocate(t *testing.T) {
}
var aSessions []*ActiveSession
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", map[string]string{utils.RunID: utils.META_DEFAULT,
utils.OriginID: smgEv.GetOriginID(utils.META_DEFAULT)}, &aSessions); err != nil {
utils.OriginID: smgEv.GetStringIgnoreErrors(utils.OriginID)}, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 {
t.Errorf("Unexpected number of sessions received: %+v", aSessions)
@@ -730,7 +744,7 @@ func TestSMGVoiceSessionTTLWithRelocate(t *testing.T) {
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eAcntVal {
t.Errorf("Expecting: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = engine.NewMapEvent(map[string]interface{}{
utils.EVENT_NAME: smgEv[utils.EVENT_NAME],
utils.ToR: smgEv[utils.ToR],
utils.InitialOriginID: smgEv[utils.OriginID],
@@ -744,7 +758,7 @@ func TestSMGVoiceSessionTTLWithRelocate(t *testing.T) {
utils.RequestType: smgEv[utils.RequestType],
utils.Usage: "2m",
utils.LastUsed: "30s",
}
})
if err := smgRPC.Call(utils.SMGenericV2UpdateSession,
smgEv, &maxUsage); err != nil {
t.Error(err)
@@ -755,7 +769,7 @@ func TestSMGVoiceSessionTTLWithRelocate(t *testing.T) {
time.Sleep(time.Duration(20) * time.Millisecond)
if err := smgRPC.Call("SMGenericV1.GetActiveSessions",
map[string]string{utils.RunID: utils.META_DEFAULT,
utils.OriginID: smgEv.GetOriginID(utils.META_DEFAULT)}, &aSessions); err != nil {
utils.OriginID: smgEv.GetStringIgnoreErrors(utils.OriginID)}, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 {
t.Errorf("Unexpected number of sessions received: %+v", aSessions)
@@ -780,13 +794,13 @@ func TestSMGVoiceSessionTTLWithRelocate(t *testing.T) {
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions",
map[string]string{utils.RunID: utils.META_DEFAULT,
utils.OriginID: smgEv.GetOriginID(utils.META_DEFAULT)},
utils.OriginID: smgEv.GetStringIgnoreErrors(utils.OriginID)},
&aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err, aSessions)
}
var cdrs []*engine.ExternalCDR
req := utils.RPCCDRsFilter{RunIDs: []string{utils.META_DEFAULT},
DestinationPrefixes: []string{smgEv.GetDestination(utils.META_DEFAULT)}}
DestinationPrefixes: []string{smgEv.GetStringIgnoreErrors(utils.Destination)}}
if err := smgRPC.Call("ApierV2.GetCdrs", req, &cdrs); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if len(cdrs) != 1 {
@@ -817,7 +831,7 @@ func TestSMGVoiceRelocateWithOriginIDPrefix(t *testing.T) {
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eAcntVal {
t.Errorf("Expecting: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv := SMGenericEvent{
smgEv := engine.NewMapEvent(map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT_RELOCATE_ORIGPREFIX",
utils.ToR: utils.VOICE,
utils.OriginID: "12371",
@@ -831,7 +845,7 @@ func TestSMGVoiceRelocateWithOriginIDPrefix(t *testing.T) {
utils.SetupTime: "2016-01-05 18:30:49",
utils.AnswerTime: "2016-01-05 18:31:05",
utils.Usage: "2m",
}
})
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
@@ -841,8 +855,10 @@ func TestSMGVoiceRelocateWithOriginIDPrefix(t *testing.T) {
}
time.Sleep(time.Duration(20) * time.Millisecond)
var aSessions []*ActiveSession
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", map[string]string{utils.RunID: utils.META_DEFAULT,
utils.OriginID: smgEv.GetOriginID(utils.META_DEFAULT)}, &aSessions); err != nil {
if err := smgRPC.Call("SMGenericV1.GetActiveSessions",
map[string]string{utils.RunID: utils.META_DEFAULT,
utils.OriginID: smgEv.GetStringIgnoreErrors(utils.OriginID)},
&aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 {
t.Errorf("Unexpected number of sessions received: %+v", aSessions)
@@ -855,7 +871,7 @@ func TestSMGVoiceRelocateWithOriginIDPrefix(t *testing.T) {
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eAcntVal {
t.Errorf("Expecting: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = map[string]interface{}{
utils.EVENT_NAME: smgEv[utils.EVENT_NAME],
utils.ToR: smgEv[utils.ToR],
utils.InitialOriginID: smgEv[utils.OriginID],
@@ -891,7 +907,7 @@ func TestSMGVoiceRelocateWithOriginIDPrefix(t *testing.T) {
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eAcntVal {
t.Errorf("Expecting: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv = SMGenericEvent{
smgEv = engine.NewMapEvent(map[string]interface{}{
utils.EVENT_NAME: smgEv[utils.EVENT_NAME],
utils.ToR: smgEv[utils.ToR],
utils.OriginIDPrefix: "12372",
@@ -903,21 +919,26 @@ func TestSMGVoiceRelocateWithOriginIDPrefix(t *testing.T) {
utils.Tenant: smgEv[utils.Tenant],
utils.RequestType: smgEv[utils.RequestType],
utils.Usage: "1m", // Total session usage
}
})
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
if err := smgRPC.Call("SMGenericV1.TerminateSession",
smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
time.Sleep(time.Duration(10) * time.Millisecond)
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", map[string]string{utils.RunID: utils.META_DEFAULT,
utils.OriginID: "12372-1"}, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
if err := smgRPC.Call("SMGenericV1.GetActiveSessions",
map[string]string{utils.RunID: utils.META_DEFAULT,
utils.OriginID: "12372-1"}, &aSessions); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err, aSessions)
}
eAcntVal = 240 * float64(time.Second)
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &acnt); err != nil {
if err := smgRPC.Call("ApierV2.GetAccount",
attrs, &acnt); err != nil {
t.Error(err)
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eAcntVal {
t.Errorf("Expecting: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
t.Errorf("Expecting: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
if err := smgRPC.Call("SMGenericV1.ProcessCDR", smgEv, &reply); err != nil {
t.Error(err)
@@ -927,7 +948,7 @@ func TestSMGVoiceRelocateWithOriginIDPrefix(t *testing.T) {
time.Sleep(time.Duration(20) * time.Millisecond)
var cdrs []*engine.ExternalCDR
req := utils.RPCCDRsFilter{RunIDs: []string{utils.META_DEFAULT},
DestinationPrefixes: []string{smgEv.GetDestination(utils.META_DEFAULT)}}
DestinationPrefixes: []string{smgEv.GetStringIgnoreErrors(utils.Destination)}}
if err := smgRPC.Call("ApierV2.GetCdrs", req, &cdrs); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if len(cdrs) != 1 {
@@ -949,7 +970,7 @@ func TestSMGDataDerivedChargingNoCredit(t *testing.T) {
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.VOICE,
utils.OriginID: "1234967",

16
sessions/smgbirpc_it_test.go
View File

@@ -37,6 +37,7 @@ var (
smgBiRPCCfg *config.CGRConfig
smgBiRPC *rpc2.Client
disconnectEvChan = make(chan *utils.AttrDisconnectSession)
err error
)
func handleDisconnectSession(clnt *rpc2.Client,
@@ -131,7 +132,7 @@ func TestSMGBiRPCSessionAutomaticDisconnects(t *testing.T) {
t.Errorf("Expecting: %f, received: %f", eAcntVal,
acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv := SMGenericEvent{
smgEv := engine.NewMapEvent(map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123451",
@@ -144,7 +145,7 @@ func TestSMGBiRPCSessionAutomaticDisconnects(t *testing.T) {
utils.RequestType: utils.META_PREPAID,
utils.SetupTime: "2016-01-05 18:30:49",
utils.AnswerTime: "2016-01-05 18:31:05",
}
})
var maxUsage float64
if err := smgBiRPC.Call(utils.SMGenericV1InitiateSession,
smgEv, &maxUsage); err != nil {
@@ -158,7 +159,7 @@ func TestSMGBiRPCSessionAutomaticDisconnects(t *testing.T) {
case <-time.After(time.Duration(50 * time.Millisecond)):
t.Error("Did not receive disconnect event")
case disconnectEv := <-disconnectEvChan:
if SMGenericEvent(disconnectEv.EventStart).GetOriginID(utils.META_DEFAULT) != smgEv[utils.OriginID] {
if engine.NewMapEvent(disconnectEv.EventStart).GetStringIgnoreErrors(utils.OriginID) != smgEv[utils.OriginID] {
t.Errorf("Unexpected event received: %+v", disconnectEv)
}
smgEv[utils.Usage] = disconnectEv.EventStart[utils.Usage]
@@ -181,7 +182,7 @@ func TestSMGBiRPCSessionAutomaticDisconnects(t *testing.T) {
time.Sleep(time.Duration(20) * time.Millisecond)
var cdrs []*engine.ExternalCDR
req := utils.RPCCDRsFilter{RunIDs: []string{utils.META_DEFAULT},
DestinationPrefixes: []string{smgEv.GetDestination(utils.META_DEFAULT)}}
DestinationPrefixes: []string{smgEv.GetStringIgnoreErrors(utils.Destination)}}
if err := smgRPC.Call("ApierV2.GetCdrs", req, &cdrs); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if len(cdrs) != 1 {
@@ -212,7 +213,7 @@ func TestSMGBiRPCSessionOriginatorTerminate(t *testing.T) {
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eAcntVal {
t.Errorf("Expecting: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv := SMGenericEvent{
smgEv := engine.NewMapEvent(map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123452",
@@ -225,7 +226,7 @@ func TestSMGBiRPCSessionOriginatorTerminate(t *testing.T) {
utils.RequestType: utils.META_PREPAID,
utils.SetupTime: "2016-01-05 18:30:49",
utils.AnswerTime: "2016-01-05 18:31:05",
}
})
var maxUsage float64
if err := smgBiRPC.Call(utils.SMGenericV1InitiateSession,
smgEv, &maxUsage); err != nil {
@@ -254,7 +255,8 @@ func TestSMGBiRPCSessionOriginatorTerminate(t *testing.T) {
}
time.Sleep(time.Duration(10) * time.Millisecond)
var cdrs []*engine.ExternalCDR
req := utils.RPCCDRsFilter{RunIDs: []string{utils.META_DEFAULT}, DestinationPrefixes: []string{smgEv.GetDestination(utils.META_DEFAULT)}}
req := utils.RPCCDRsFilter{RunIDs: []string{utils.META_DEFAULT},
DestinationPrefixes: []string{smgEv.GetStringIgnoreErrors(utils.Destination)}}
if err := smgRPC.Call("ApierV2.GetCdrs", req, &cdrs); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if len(cdrs) != 1 {

14
sessions/smgreplc_it_test.go
View File

@@ -95,7 +95,7 @@ func TestSMGRplcInitiate(t *testing.T) {
nil, &pSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123451",
@@ -146,7 +146,7 @@ func TestSMGRplcInitiate(t *testing.T) {
// Update on slave
func TestSMGRplcUpdate(t *testing.T) {
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.OriginID: "123451",
utils.Usage: "1m",
@@ -180,7 +180,7 @@ func TestSMGRplcUpdate(t *testing.T) {
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
cgrID := smgEv.GetCGRID(utils.META_DEFAULT)
cgrID := GetSetCGRID(engine.NewSafEvent(smgEv))
// Make sure session was replicated
if err := smgRplcMstrRPC.Call("SMGenericV1.GetPassiveSessions",
nil, &pSessions); err != nil {
@@ -196,7 +196,7 @@ func TestSMGRplcUpdate(t *testing.T) {
}
func TestSMGRplcTerminate(t *testing.T) {
smgEv := SMGenericEvent{
smgEv := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.OriginID: "123451",
utils.Usage: "3m",
@@ -230,7 +230,7 @@ func TestSMGRplcManualReplicate(t *testing.T) {
if smgRplcMstrRPC, err = jsonrpc.Dial("tcp", smgRplcMasterCfg.RPCJSONListen); err != nil {
t.Fatal(err)
}
smgEv1 := SMGenericEvent{
smgEv1 := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123451",
@@ -245,7 +245,7 @@ func TestSMGRplcManualReplicate(t *testing.T) {
utils.AnswerTime: "2016-01-05 18:31:05",
utils.Usage: "1m30s",
}
smgEv2 := SMGenericEvent{
smgEv2 := map[string]interface{}{
utils.EVENT_NAME: "TEST_EVENT",
utils.ToR: utils.VOICE,
utils.OriginID: "123481",
@@ -260,7 +260,7 @@ func TestSMGRplcManualReplicate(t *testing.T) {
utils.AnswerTime: "2016-01-05 18:31:05",
utils.Usage: "1m30s",
}
for _, smgEv := range []SMGenericEvent{smgEv1, smgEv2} {
for _, smgEv := range []map[string]interface{}{smgEv1, smgEv2} {
var maxUsage time.Duration
if err := smgRplcMstrRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)