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

Using SMGenericV2 methods returning time.Duration as maxDuration instead of float, updated smg_it tests

Browse Source
This commit is contained in:
DanB
2017-11-06 18:20:17 +01:00
parent 286ef0c0aa
commit 86fd8444db
10 changed files with 109 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
agents/dmtagent.go
View File

@@ -138,9 +138,9 @@ func (self DiameterAgent) processCCR(ccr *CCR, reqProcessor *config.DARequestPro
} else { // Find out maxUsage over APIs
switch ccr.CCRequestType {
case 1:
err = self.smg.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage)
err = self.smg.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage)
case 2:
err = self.smg.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage)
err = self.smg.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage)
case 3, 4: // Handle them together since we generate CDR for them
var rpl string
if ccr.CCRequestType == 3 {

5
apier/v2/smgeneric.go
View File

@@ -43,3 +43,8 @@ func (smgv2 *SMGenericV2) InitiateSession(ev sessionmanager.SMGenericEvent, maxU
func (smgv2 *SMGenericV2) UpdateSession(ev sessionmanager.SMGenericEvent, maxUsage *time.Duration) error {
return smgv2.SMG.BiRPCV2UpdateSession(nil, ev, maxUsage)
}
// Called on individual Events (eg SMS)
func (smgv2 *SMGenericV2) ChargeEvent(ev sessionmanager.SMGenericEvent, maxUsage *time.Duration) error {
return smgv2.SMG.BiRPCV2ChargeEvent(nil, ev, maxUsage)
}

5
general_tests/a1_it_test.go
View File

@@ -146,7 +146,7 @@ func TestA1itDataSession1(t *testing.T) {
utils.SessionTTLUsage: "0s",
}
var maxUsage float64
if err := a1rpc.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := a1rpc.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
} else if maxUsage != 0.000010240 {
t.Error("Received: ", maxUsage)
@@ -171,7 +171,8 @@ func TestA1itDataSession1(t *testing.T) {
utils.ANSWER_TIME: "2017-03-03 11:39:32 +0100 CET",
utils.USAGE: "2097152",
}
if err := a1rpc.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := a1rpc.Call(utils.SMGenericV2UpdateSession,
smgEv, &maxUsage); err != nil {
t.Error(err)
} else if maxUsage != 0.002097152 {
t.Error("Bad max usage: ", maxUsage)

44
sessionmanager/data_it_test.go
View File

@@ -108,10 +108,10 @@ func TestSMGDataLastUsedData(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
if maxUsage != 0.001048576 {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 49998945280.000000 //1054720
@@ -136,7 +136,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -200,7 +200,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -232,7 +232,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -263,7 +263,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -294,7 +294,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -325,7 +325,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -395,7 +395,7 @@ func TestSMGDataDerivedChargingNoCredit(t *testing.T) {
utils.USAGE: "100",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
// the second derived charging run has no credit
@@ -436,7 +436,7 @@ func TestSMGDataTTLExpired(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -482,7 +482,7 @@ func TestSMGDataTTLExpiredMultiUpdates(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -515,7 +515,7 @@ func TestSMGDataTTLExpiredMultiUpdates(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -565,7 +565,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -597,7 +597,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "0",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -628,7 +628,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "0",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -659,7 +659,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "0",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -690,7 +690,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "0",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -760,7 +760,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -793,7 +793,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -824,7 +824,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -855,7 +855,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -886,7 +886,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV2.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {

5
sessionmanager/smasterisk.go
View File

@@ -25,6 +25,7 @@ import (
"strconv"
"strings"
"sync"
"time"
"github.com/cgrates/aringo"
"github.com/cgrates/cgrates/config"
@@ -180,8 +181,8 @@ func (sma *SMAsterisk) handleChannelStateChange(ev *SMAsteriskEvent) {
}
return
}
var maxUsage float64
if err := sma.smg.Call("SMGenericV1.InitiateSession", *smgEv, &maxUsage); err != nil {
var maxUsage time.Duration
if err := sma.smg.Call(utils.SMGenericV2InitiateSession, *smgEv, &maxUsage); err != nil {
utils.Logger.Err(fmt.Sprintf("<SMAsterisk> Error: %s when attempting to initiate session for channelID: %s", err.Error(), ev.ChannelID()))
if err := sma.hangupChannel(ev.ChannelID()); err != nil {
utils.Logger.Err(fmt.Sprintf("<SMAsterisk> Error: %s when attempting to disconnect channelID: %s", err.Error(), ev.ChannelID()))

88
sessionmanager/smg_it_test.go
View File

@@ -107,11 +107,12 @@ func TestSMGVoiceMonetaryRefund(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "1m30s",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession,
smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 90 {
if maxUsage != time.Duration(90*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
var acnt *engine.Account
@@ -165,11 +166,12 @@ func TestSMGVoiceVoiceRefund(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "1m30s",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession,
smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 90 {
if maxUsage != time.Duration(90*time.Second) {
t.Error("Received: ", maxUsage)
}
var acnt *engine.Account
@@ -178,7 +180,8 @@ func TestSMGVoiceVoiceRefund(t *testing.T) {
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())
t.Errorf("Expected: %f, received: %f",
eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue())
}
smgEv = SMGenericEvent{
utils.EVENT_NAME: "TEST_EVENT",
@@ -230,11 +233,11 @@ func TestSMGVoiceMixedRefund(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "1m30s",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 90 {
if maxUsage != time.Duration(90*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
//var acnt *engine.Account
@@ -302,11 +305,11 @@ func TestSMGVoiceLastUsed(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "2m",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 7.39002
@@ -329,10 +332,10 @@ func TestSMGVoiceLastUsed(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "1m30s",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call(utils.SMGenericV2UpdateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 7.09005
@@ -355,10 +358,10 @@ func TestSMGVoiceLastUsed(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "2m30s",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call(utils.SMGenericV2UpdateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 6.590100
@@ -416,11 +419,11 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "2m",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 6.190020
@@ -443,10 +446,10 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "30s",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call(utils.SMGenericV2UpdateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 6.090030
@@ -504,11 +507,11 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "2m",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 5.190020
@@ -531,10 +534,10 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "13s",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call(utils.SMGenericV2UpdateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
eAcntVal = 5.123360
@@ -592,12 +595,12 @@ func TestSMGVoiceSessionTTL(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "2m",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
time.Sleep(time.Duration(30 * time.Millisecond))
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
var aSessions []*ActiveSession
@@ -629,11 +632,11 @@ func TestSMGVoiceSessionTTL(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "30s",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call(utils.SMGenericV2UpdateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
time.Sleep(time.Duration(10 * time.Millisecond))
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
if err := smgRPC.Call("SMGenericV1.GetActiveSessions", map[string]string{utils.MEDI_RUNID: utils.META_DEFAULT, utils.ACCID: "12360"}, &aSessions); err != nil {
@@ -704,12 +707,12 @@ func TestSMGVoiceSessionTTLWithRelocate(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "2m",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
time.Sleep(time.Duration(10) * time.Millisecond)
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
var aSessions []*ActiveSession
@@ -742,10 +745,11 @@ func TestSMGVoiceSessionTTLWithRelocate(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "30s",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call(utils.SMGenericV2UpdateSession,
smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
time.Sleep(time.Duration(20) * time.Millisecond)
@@ -828,11 +832,11 @@ func TestSMGVoiceRelocateWithOriginIDPrefix(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
utils.USAGE: "2m",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
var maxUsage time.Duration
if err := smgRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
time.Sleep(time.Duration(20) * time.Millisecond)
@@ -866,10 +870,10 @@ func TestSMGVoiceRelocateWithOriginIDPrefix(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "30s",
}
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call(utils.SMGenericV2UpdateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
if maxUsage != time.Duration(120*time.Second) {
t.Error("Bad max usage: ", maxUsage)
}
time.Sleep(time.Duration(20) * time.Millisecond)

8
sessionmanager/smgbirpc_it_test.go
View File

@@ -144,7 +144,7 @@ func TestSMGBiRPCSessionAutomaticDisconnects(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
}
var maxUsage float64
if err := smgBiRPC.Call("SMGenericV1.InitiateSession",
if err := smgBiRPC.Call(utils.SMGenericV1InitiateSession,
smgEv, &maxUsage); err != nil {
t.Error(err)
}
@@ -225,7 +225,8 @@ func TestSMGBiRPCSessionOriginatorTerminate(t *testing.T) {
utils.ANSWER_TIME: "2016-01-05 18:31:05",
}
var maxUsage float64
if err := smgBiRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := smgBiRPC.Call(utils.SMGenericV1InitiateSession,
smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != -1 {
@@ -234,7 +235,8 @@ func TestSMGBiRPCSessionOriginatorTerminate(t *testing.T) {
time.Sleep(time.Duration(10 * time.Millisecond)) // Give time for debits to occur
smgEv[utils.USAGE] = "7ms"
var rpl string
if err = smgBiRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgBiRPC.Call("SMGenericV1.TerminateSession",
smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
time.Sleep(time.Duration(50 * time.Millisecond)) // Give time for debits to occur

10
sessionmanager/smgeneric.go
View File

@@ -1128,6 +1128,16 @@ func (smg *SMGeneric) BiRPCV1ChargeEvent(clnt rpcclient.RpcClientConnection, ev
return nil
}
// Called on individual Events (eg SMS)
func (smg *SMGeneric) BiRPCV2ChargeEvent(clnt rpcclient.RpcClientConnection, ev SMGenericEvent, maxUsage *time.Duration) error {
if minMaxUsage, err := smg.ChargeEvent(ev); err != nil {
return utils.NewErrServerError(err)
} else {
*maxUsage = minMaxUsage
}
return nil
}
// Called on session end, should send the CDR to CDRS
func (smg *SMGeneric) BiRPCV1ProcessCDR(clnt rpcclient.RpcClientConnection, ev SMGenericEvent, reply *string) error {
if err := smg.ProcessCDR(ev); err != nil {

14
sessionmanager/smgreplc_it_test.go
View File

@@ -91,7 +91,8 @@ func TestSMGRplcTPFromFolder(t *testing.T) {
func TestSMGRplcInitiate(t *testing.T) {
var pSessions []*ActiveSession
if err := smgRplcSlvRPC.Call("SMGenericV1.GetPassiveSessions", nil, &pSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
if err := smgRplcSlvRPC.Call("SMGenericV1.GetPassiveSessions",
nil, &pSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
smgEv := SMGenericEvent{
@@ -110,14 +111,16 @@ func TestSMGRplcInitiate(t *testing.T) {
utils.USAGE: "1m30s",
}
var maxUsage float64
if err := smgRplcMstrRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err == nil && err.Error() != rpcclient.ErrSessionNotFound.Error() { // Update should return rpcclient.ErrSessionNotFound
if err := smgRplcMstrRPC.Call(utils.SMGenericV2UpdateSession,
smgEv, &maxUsage); err == nil &&
err.Error() != rpcclient.ErrSessionNotFound.Error() { // Update should return rpcclient.ErrSessionNotFound
t.Error(err)
}
var reply string
if err := smgRplcMstrRPC.Call("SMGenericV1.TerminateSession", smgEv, &reply); err == nil && err.Error() != rpcclient.ErrSessionNotFound.Error() { // Update should return rpcclient.ErrSessionNotFound
t.Error(err)
}
if err := smgRplcMstrRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := smgRplcMstrRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 90 {
@@ -149,7 +152,8 @@ func TestSMGRplcUpdate(t *testing.T) {
utils.USAGE: "1m",
}
var maxUsage float64
if err := smgRplcSlvRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
if err := smgRplcSlvRPC.Call(utils.SMGenericV2UpdateSession,
smgEv, &maxUsage); err != nil {
t.Error(err)
} else if maxUsage != 60 {
t.Error("Bad max usage: ", maxUsage)
@@ -253,7 +257,7 @@ func TestSMGRplcManualReplicate(t *testing.T) {
}
for _, smgEv := range []SMGenericEvent{smgEv1, smgEv2} {
var maxUsage float64
if err := smgRplcMstrRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
if err := smgRplcMstrRPC.Call(utils.SMGenericV2InitiateSession, smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 90 {

4
utils/consts.go
View File

@@ -488,6 +488,10 @@ const (
Action = "Action"
ThresholdSv1ProcessEvent = "ThresholdSv1.ProcessEvent"
MetaNow = "*now"
SMGenericV2UpdateSession = "SMGenericV2.UpdateSession"
SMGenericV2InitiateSession = "SMGenericV2.InitiateSession"
SMGenericV1UpdateSession = "SMGenericV1.UpdateSession"
SMGenericV1InitiateSession = "SMGenericV1.InitiateSession"
)
func buildCacheInstRevPrefixes() {