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

Updating data integration test

Browse Source
This commit is contained in:
DanB
2017-11-21 16:24:23 +01:00
parent 16d477ccd9
commit 219d6ab6c5
1 changed files with 0 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

351
sessionmanager/data_it_test.go
View File

@@ -306,46 +306,6 @@ func TestSMGDataLastUsedMultipleUpdates(t *testing.T) {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 8192 {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 87040.000000 // 15MB used
if err := smgRPC.Call("ApierV2.GetAccount", acntAttrs, &acnt); err != nil {
t.Error(err)
} else if totalVal := acnt.BalanceMap[utils.DATA].GetTotalValue(); totalVal != eAcntVal {
t.Errorf("Expected: %f, received: %f", totalVal)
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", nil, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 ||
aSessions[0].Usage != time.Duration(15360) {
t.Errorf("wrong active sessions: %f", aSessions[0].Usage)
}
smgEv = SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
utils.ACCID: "123492",
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: acntAttrs.Account,
utils.SUBJECT: acntAttrs.Account,
utils.DESTINATION: utils.DATA,
utils.CATEGORY: "data",
utils.TENANT: acntAttrs.Tenant,
utils.REQTYPE: utils.META_PREPAID,
<<<<<<< HEAD
utils.USAGE: "1048576",
utils.LastUsed: "20000",
>>>>>>> Using SMGenericV2 methods returning time.Duration as maxDuration instead of float, updated smg_it tests
=======
utils.SETUP_TIME: "2016-01-05 18:30:50",
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "1024", // 8 MB
utils.LastUsed: "5120", // 5 MB
>>>>>>> Redesigned core to support nanoseconds/data units, cgr-engine memory profiling in commandline options, tests updates
}
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1024 {
t.Error("Bad max usage: ", maxUsage)
}
@@ -423,59 +383,7 @@ func TestSMGDataLastUsedMultipleUpdates(t *testing.T) {
nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err, aSessions)
}
<<<<<<< HEAD
<<<<<<< HEAD
if err := smgRPC.Call("SMGenericV1.ProcessCDR", smgEv, &reply); err != nil {
=======
=======
if err := smgRPC.Call("SMGenericV1.ProcessCDR", smgEv, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Received reply: %s", reply)
}
time.Sleep(time.Duration(10) * time.Millisecond)
var cdrs []*engine.ExternalCDR
req := utils.RPCCDRsFilter{RunIDs: []string{utils.META_DEFAULT},
Accounts: []string{acntAttrs.Account}}
if err := smgRPC.Call("ApierV2.GetCdrs", req, &cdrs); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if len(cdrs) != 1 {
t.Error("Unexpected number of CDRs returned: ", len(cdrs))
} else {
if cdrs[0].Usage != "13312" {
t.Errorf("Unexpected CDR Usage received, cdr: %v %+v ", cdrs[0].Usage, cdrs[0])
}
}
>>>>>>> Redesigned core to support nanoseconds/data units, cgr-engine memory profiling in commandline options, tests updates
}
func TestSMGDataDerivedChargingNoCredit(t *testing.T) {
var acnt *engine.Account
attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1011"}
eAcntVal := 50000.0
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &acnt); err != nil {
t.Error(err)
} else if acnt.BalanceMap[utils.VOICE].GetTotalValue() != eAcntVal {
t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv := SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.VOICE,
utils.ACCID: "1234967",
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: "1011",
utils.SUBJECT: "1011",
utils.DESTINATION: "+49",
utils.CATEGORY: "call",
utils.TENANT: "cgrates.org",
utils.REQTYPE: utils.META_PREPAID,
utils.SETUP_TIME: "2016-01-05 18:30:49",
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "100",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
>>>>>>> Using SMGenericV2 methods returning time.Duration as maxDuration instead of float, updated smg_it tests
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Received reply: %s", reply)
@@ -590,11 +498,7 @@ func TestSMGDataTTLExpMultiUpdates(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "4096", // 3MB
}
<<<<<<< HEAD
var maxUsage int64
=======
var maxUsage float64
>>>>>>> Using SMGenericV2 methods returning time.Duration as maxDuration instead of float, updated smg_it tests
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
@@ -615,7 +519,6 @@ func TestSMGDataTTLExpMultiUpdates(t *testing.T) {
t.Errorf("wrong active sessions: %d", int64(aSessions[0].Usage))
}
smgEv = SMGenericEvent{
<<<<<<< HEAD
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
utils.ACCID: "123495",
@@ -636,25 +539,6 @@ func TestSMGDataTTLExpMultiUpdates(t *testing.T) {
t.Error(err)
}
if maxUsage != 4096 {
=======
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
utils.ACCID: "123495",
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: "1010",
utils.SUBJECT: "1010",
utils.DESTINATION: "222",
utils.CATEGORY: "data",
utils.TENANT: "cgrates.org",
utils.REQTYPE: utils.META_PREPAID,
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
>>>>>>> Using SMGenericV2 methods returning time.Duration as maxDuration instead of float, updated smg_it tests
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 97280.000000 // 20480
@@ -712,11 +596,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "2048",
}
<<<<<<< HEAD
var maxUsage int64
=======
var maxUsage float64
>>>>>>> Using SMGenericV2 methods returning time.Duration as maxDuration instead of float, updated smg_it tests
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
@@ -732,85 +612,14 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
aSessions := make([]*ActiveSession, 0)
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", nil, &aSessions); err != nil {
t.Error(err)
<<<<<<< HEAD
} else if len(aSessions) != 1 ||
int64(aSessions[0].Usage) != 2048 {
t.Errorf("wrong active sessions usage: %d", int64(aSessions[0].Usage))
=======
} else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1048576 {
t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds())
}
smgEv = SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
utils.ACCID: "123496",
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: "1010",
utils.SUBJECT: "1010",
utils.DESTINATION: "222",
utils.CATEGORY: "data",
utils.TENANT: "cgrates.org",
utils.REQTYPE: utils.META_PREPAID,
utils.USAGE: "1048576",
utils.LastUsed: "0",
}
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 49996712960.000000 // 0
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &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())
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", nil, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1048576 {
t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds())
>>>>>>> Using SMGenericV2 methods returning time.Duration as maxDuration instead of float, updated smg_it tests
}
smgEv = SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
<<<<<<< HEAD
utils.ACCID: "123495",
=======
utils.ACCID: "123496",
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: "1010",
utils.SUBJECT: "1010",
utils.DESTINATION: "222",
utils.CATEGORY: "data",
utils.TENANT: "cgrates.org",
utils.REQTYPE: utils.META_PREPAID,
utils.USAGE: "1048576",
utils.LastUsed: "0",
}
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 49996712960.000000 // 0
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &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())
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", nil, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1048576 {
t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds())
}
smgEv = SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
utils.ACCID: "123496",
>>>>>>> Using SMGenericV2 methods returning time.Duration as maxDuration instead of float, updated smg_it tests
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: acntAttrs.Account,
utils.SUBJECT: acntAttrs.Account,
@@ -949,11 +758,7 @@ func TestSMGDataTTLUsageProtection(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "2048",
}
<<<<<<< HEAD
var maxUsage int64
=======
var maxUsage float64
>>>>>>> Using SMGenericV2 methods returning time.Duration as maxDuration instead of float, updated smg_it tests
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
@@ -969,7 +774,6 @@ func TestSMGDataTTLUsageProtection(t *testing.T) {
aSessions := make([]*ActiveSession, 0)
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", nil, &aSessions); err != nil {
t.Error(err)
<<<<<<< HEAD
} else if len(aSessions) != 1 ||
int64(aSessions[0].Usage) != 2048 {
t.Errorf("wrong active sessions usage: %d", int64(aSessions[0].Usage))
@@ -978,160 +782,5 @@ func TestSMGDataTTLUsageProtection(t *testing.T) {
if err := smgRPC.Call("SMGenericV1.GetActiveSessions",
nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err, aSessions)
=======
} else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1048576 {
t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds())
}
smgEv = SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
utils.ACCID: "123497",
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: "1010",
utils.SUBJECT: "1010",
utils.DESTINATION: "222",
utils.CATEGORY: "data",
utils.TENANT: "cgrates.org",
utils.REQTYPE: utils.META_PREPAID,
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 49996712960.000000 // 0
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &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())
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", nil, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1049176 {
t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds())
}
smgEv = SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
utils.ACCID: "123497",
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: "1010",
utils.SUBJECT: "1010",
utils.DESTINATION: "222",
utils.CATEGORY: "data",
utils.TENANT: "cgrates.org",
utils.REQTYPE: utils.META_PREPAID,
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 49996712960.000000 // 0
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &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())
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", nil, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1049776 {
t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds())
}
smgEv = SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
utils.ACCID: "123497",
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: "1010",
utils.SUBJECT: "1010",
utils.DESTINATION: "222",
utils.CATEGORY: "data",
utils.TENANT: "cgrates.org",
utils.REQTYPE: utils.META_PREPAID,
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 49996712960.000000 // 0
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &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())
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", nil, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1050376 {
t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds())
}
smgEv = SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
utils.ACCID: "123497",
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: "1010",
utils.SUBJECT: "1010",
utils.DESTINATION: "222",
utils.CATEGORY: "data",
utils.TENANT: "cgrates.org",
utils.REQTYPE: utils.META_PREPAID,
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 49996712960.000000 // 0
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &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())
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", nil, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1050976 {
t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds())
}
smgEv = SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
utils.TOR: utils.DATA,
utils.ACCID: "123497",
utils.DIRECTION: utils.OUT,
utils.ACCOUNT: "1010",
utils.SUBJECT: "1010",
utils.DESTINATION: "222",
utils.CATEGORY: "data",
utils.TENANT: "cgrates.org",
utils.REQTYPE: utils.META_PREPAID,
utils.LastUsed: "0",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 49997757440.000000 // 10240 (from the start)
if err := smgRPC.Call("ApierV2.GetAccount", attrs, &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())
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
>>>>>>> Using SMGenericV2 methods returning time.Duration as maxDuration instead of float, updated smg_it tests
}
}