From 03ca558963ae6ac75d5a69bcce1d9a48c2d81225 Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Fri, 29 Apr 2016 13:24:17 +0300 Subject: [PATCH 01/11] fix for SetActions API --- apier/v1/apier.go | 2 +- data/tariffplans/testtp/AccountActions.csv | 3 +- general_tests/tp_it_test.go | 52 ++++++++++++++++++++++ utils/apitpdata.go | 1 + 4 files changed, 56 insertions(+), 2 deletions(-) diff --git a/apier/v1/apier.go b/apier/v1/apier.go index cf3f86389..28aceee33 100644 --- a/apier/v1/apier.go +++ b/apier/v1/apier.go @@ -530,7 +530,7 @@ func (self *ApierV1) SetActions(attrs utils.AttrSetActions, reply *string) error ExtraParameters: apiAct.ExtraParameters, Filter: apiAct.Filter, Balance: &engine.BalanceFilter{ // TODO: update this part - Uuid: utils.StringPointer(utils.GenUUID()), + Uuid: utils.StringPointer(apiAct.BalanceUuid), ID: utils.StringPointer(apiAct.BalanceId), Type: utils.StringPointer(apiAct.BalanceType), Value: vf, diff --git a/data/tariffplans/testtp/AccountActions.csv b/data/tariffplans/testtp/AccountActions.csv index 850d03f77..9fa3f8977 100644 --- a/data/tariffplans/testtp/AccountActions.csv +++ b/data/tariffplans/testtp/AccountActions.csv @@ -9,4 +9,5 @@ cgrates.org,1010,TEST_DATA_r,,true, cgrates.org,1011,TEST_VOICE,,, cgrates.org,1012,PREPAID_10,,, cgrates.org,1013,TEST_NEG,,, -cgrates.org,1014,TEST_RPC,,, \ No newline at end of file +cgrates.org,1014,TEST_RPC,,, +cgrates.org,1015,,,, diff --git a/general_tests/tp_it_test.go b/general_tests/tp_it_test.go index 8165ed19c..bb7560921 100644 --- a/general_tests/tp_it_test.go +++ b/general_tests/tp_it_test.go @@ -239,3 +239,55 @@ func TestTpExecuteActionCgrRpc(t *testing.T) { t.Error("Got error on ApierV2.GetAccount: ", err.Error()) } } + +func TestTpCreateExecuteActionMatch(t *testing.T) { + if !*testIntegration { + return + } + var reply string + if err := tpRPC.Call("ApierV2.SetActions", utils.AttrSetActions{ + ActionsId: "PAYMENT_2056bd2fe137082970f97102b64e42fd", + Actions: []*utils.TPAction{ + &utils.TPAction{ + BalanceType: "*monetary", + Directions: "*out", + Identifier: "*topup", + RatingSubject: "", + Units: "10.500000", + Weight: 10, + }, + }, + }, &reply); err != nil { + t.Error("Got error on ApierV2.SetActions: ", err.Error()) + } else if reply != utils.OK { + t.Errorf("Calling ApierV2.SetActions got reply: %s", reply) + } + if err := tpRPC.Call("ApierV2.ExecuteAction", utils.AttrExecuteAction{ + Tenant: "cgrates.org", + Account: "1015", + ActionsId: "PAYMENT_2056bd2fe137082970f97102b64e42fd", + }, &reply); err != nil { + t.Error("Got error on ApierV2.ExecuteAction: ", err.Error()) + } else if reply != utils.OK { + t.Errorf("Calling ExecuteAction got reply: %s", reply) + } + if err := tpRPC.Call("ApierV2.ExecuteAction", utils.AttrExecuteAction{ + Tenant: "cgrates.org", + Account: "1015", + ActionsId: "PAYMENT_2056bd2fe137082970f97102b64e42fd", + }, &reply); err != nil { + t.Error("Got error on ApierV2.ExecuteAction: ", err.Error()) + } else if reply != utils.OK { + t.Errorf("Calling ExecuteAction got reply: %s", reply) + } + var acnt engine.Account + attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1015"} + if err := tpRPC.Call("ApierV2.GetAccount", attrs, &acnt); err != nil { + t.Error("Got error on ApierV2.GetAccount: ", err.Error()) + } + if len(acnt.BalanceMap) != 1 || + len(acnt.BalanceMap[utils.MONETARY]) != 1 || + acnt.BalanceMap[utils.MONETARY].GetTotalValue() != 21 { + t.Error("error matching previous created balance: ", utils.ToIJSON(acnt.BalanceMap)) + } +} diff --git a/utils/apitpdata.go b/utils/apitpdata.go index 62f38434b..12bfc9173 100644 --- a/utils/apitpdata.go +++ b/utils/apitpdata.go @@ -275,6 +275,7 @@ type TPActions struct { type TPAction struct { Identifier string // Identifier mapped in the code BalanceId string // Balance identification string (account scope) + BalanceUuid string // Balance identification string (global scope) BalanceType string // Type of balance the action will operate on Directions string // Balance direction Units string // Number of units to add/deduct From 1822e895a45f338a9de4f825fd102a1e6bd832ea Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Fri, 29 Apr 2016 15:22:06 +0300 Subject: [PATCH 02/11] more data usage tests --- sessionmanager/data_it_test.go | 342 +++++++++++++++++++++++++++++++++ 1 file changed, 342 insertions(+) diff --git a/sessionmanager/data_it_test.go b/sessionmanager/data_it_test.go index dd21c6c8c..d8422d118 100644 --- a/sessionmanager/data_it_test.go +++ b/sessionmanager/data_it_test.go @@ -510,3 +510,345 @@ func TestSMGDataTTLExpiredMultiUpdates(t *testing.T) { t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.DATA].GetTotalValue()) } } + +func TestSMGDataLastUsedMultipleDataNoUsage(t *testing.T) { + if !*testIntegration { + return + } + var acnt *engine.Account + attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1010"} + eAcntVal := 49997767680.000000 + 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()) + } + smgEv := SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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.SETUP_TIME: "2016-01-05 18:30:49", + utils.ANSWER_TIME: "2016-01-05 18:31:05", + utils.USAGE: "1048576", + } + var maxUsage float64 + if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil { + t.Error(err) + } + if maxUsage != 1.048576e+06 { + t.Error("Bad max usage: ", maxUsage) + } + eAcntVal = 49996712960.000000 // 1054720 + 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()) + } + smgEv = SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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("SMGenericV1.SessionUpdate", 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()) + } + smgEv = SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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("SMGenericV1.SessionUpdate", 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()) + } + + smgEv = SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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("SMGenericV1.SessionUpdate", 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()) + } + smgEv = SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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("SMGenericV1.SessionUpdate", 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()) + } + + smgEv = SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK { + t.Error(err) + } + eAcntVal = 49997767680.000000 // refunded + 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()) + } +} + +func TestSMGDataLastUsedMultipleDataConstantUsage(t *testing.T) { + if !*testIntegration { + return + } + var acnt *engine.Account + attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1010"} + eAcntVal := 49997767680.000000 + 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()) + } + smgEv := SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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.SETUP_TIME: "2016-01-05 18:30:49", + utils.ANSWER_TIME: "2016-01-05 18:31:05", + utils.USAGE: "1048576", + } + var maxUsage float64 + if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil { + t.Error(err) + } + if maxUsage != 1.048576e+06 { + t.Error("Bad max usage: ", maxUsage) + } + eAcntVal = 49996712960.000000 // 1054720 + 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()) + } + smgEv = SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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("SMGenericV1.SessionUpdate", 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()) + } + smgEv = SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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("SMGenericV1.SessionUpdate", 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()) + } + + smgEv = SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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("SMGenericV1.SessionUpdate", 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()) + } + smgEv = SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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("SMGenericV1.SessionUpdate", 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()) + } + + smgEv = SMGenericEvent{ + utils.EVENT_NAME: "TEST_EVENT", + utils.TOR: utils.DATA, + utils.ACCID: "12349", + 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.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK { + t.Error(err) + } + eAcntVal = 49997767680.000000 // refunded + 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()) + } +} From ee5d5b0bedb0998ef5fa635206e5f4a5b40d07a7 Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Fri, 29 Apr 2016 16:38:50 +0300 Subject: [PATCH 03/11] value formula string method --- apier/v1/apier.go | 5 +++-- utils/value_formula.go | 4 ++++ 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/apier/v1/apier.go b/apier/v1/apier.go index 28aceee33..f65b3df94 100644 --- a/apier/v1/apier.go +++ b/apier/v1/apier.go @@ -562,7 +562,8 @@ func (self *ApierV1) GetActions(actsId string, reply *[]*utils.TPAction) error { return utils.NewErrServerError(err) } for _, engAct := range engActs { - act := &utils.TPAction{Identifier: engAct.ActionType, + act := &utils.TPAction{ + Identifier: engAct.ActionType, ExpiryTime: engAct.ExpirationString, ExtraParameters: engAct.ExtraParameters, Filter: engAct.Filter, @@ -571,7 +572,7 @@ func (self *ApierV1) GetActions(actsId string, reply *[]*utils.TPAction) error { bf := engAct.Balance if bf != nil { act.BalanceType = bf.GetType() - act.Units = strconv.FormatFloat(bf.GetValue(), 'f', -1, 64) + act.Units = bf.Value.String() act.Directions = bf.GetDirections().String() act.DestinationIds = bf.GetDestinationIDs().String() act.RatingSubject = bf.GetRatingSubject() diff --git a/utils/value_formula.go b/utils/value_formula.go index 1ac113aa1..1e6221087 100644 --- a/utils/value_formula.go +++ b/utils/value_formula.go @@ -37,6 +37,10 @@ var ValueFormulas = map[string]valueFormula{ INCREMENTAL: incrementalFormula, } +func (vf *ValueFormula) String() string { + return ToJSON(vf) +} + func incrementalFormula(params map[string]interface{}) float64 { // check parameters unitsInterface, unitsFound := params["Units"] From dd48ee768778a449ffe9f993fd2ffb62a19e6237 Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Fri, 29 Apr 2016 17:35:09 +0300 Subject: [PATCH 04/11] data usage fix --- sessionmanager/data_it_test.go | 2 +- sessionmanager/smg_session.go | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/sessionmanager/data_it_test.go b/sessionmanager/data_it_test.go index d8422d118..aecd35abd 100644 --- a/sessionmanager/data_it_test.go +++ b/sessionmanager/data_it_test.go @@ -845,7 +845,7 @@ func TestSMGDataLastUsedMultipleDataConstantUsage(t *testing.T) { if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK { t.Error(err) } - eAcntVal = 49997767680.000000 // refunded + 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 { diff --git a/sessionmanager/smg_session.go b/sessionmanager/smg_session.go index d1701a905..79160139c 100644 --- a/sessionmanager/smg_session.go +++ b/sessionmanager/smg_session.go @@ -90,13 +90,15 @@ func (self *SMGSession) debit(dur time.Duration, lastUsed *time.Duration) (time. // total usage correction self.totalUsage -= self.lastUsage self.totalUsage += *lastUsed - //utils.Logger.Debug(fmt.Sprintf("Correction: %f", self.totalUsage.Seconds())) + //utils.Logger.Debug(fmt.Sprintf("TotalUsage Correction: %f", self.totalUsage.Seconds())) } } // apply correction from previous run if self.extraDuration < dur { dur -= self.extraDuration } else { + self.lastUsage = requestedDuration + self.totalUsage += self.lastUsage ccDuration := self.extraDuration // fake ccDuration self.extraDuration -= dur return ccDuration, nil From ff0c94c18a7416bba147a18f37c46142b494bc96 Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Fri, 29 Apr 2016 18:36:09 +0300 Subject: [PATCH 05/11] tests for total usage --- sessionmanager/data_it_test.go | 309 ++++++++++++++++++++++----------- sessionmanager/smg_session.go | 1 + 2 files changed, 205 insertions(+), 105 deletions(-) diff --git a/sessionmanager/data_it_test.go b/sessionmanager/data_it_test.go index aecd35abd..726e6d5d4 100644 --- a/sessionmanager/data_it_test.go +++ b/sessionmanager/data_it_test.go @@ -212,6 +212,12 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) { } else if acnt.BalanceMap[utils.DATA].GetTotalValue() != eAcntVal { t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.DATA].GetTotalValue()) } + aSessions := make([]*ActiveSession, 0) + if err := smgRPC.Call("SMGenericV1.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &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, @@ -238,6 +244,11 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); err != nil { + t.Error(err) + } else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1068576 { + t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds()) + } smgEv = SMGenericEvent{ utils.EVENT_NAME: "TEST_EVENT", utils.TOR: utils.DATA, @@ -264,7 +275,11 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); err != nil { + t.Error(err) + } else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1088576 { + t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds()) + } smgEv = SMGenericEvent{ utils.EVENT_NAME: "TEST_EVENT", utils.TOR: utils.DATA, @@ -291,6 +306,11 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); err != nil { + t.Error(err) + } else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1108576 { + t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds()) + } smgEv = SMGenericEvent{ utils.EVENT_NAME: "TEST_EVENT", utils.TOR: utils.DATA, @@ -317,7 +337,11 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); err != nil { + t.Error(err) + } else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1128576 { + t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds()) + } smgEv = SMGenericEvent{ utils.EVENT_NAME: "TEST_EVENT", utils.TOR: utils.DATA, @@ -341,6 +365,11 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); err != nil { + t.Error(err) + } else if len(aSessions) != 0 { + t.Errorf("wrong active sessions: %+v", aSessions) + } } func TestSMGDataDerivedChargingNoCredit(t *testing.T) { @@ -474,6 +503,12 @@ func TestSMGDataTTLExpiredMultiUpdates(t *testing.T) { } else if acnt.BalanceMap[utils.DATA].GetTotalValue() != eAcntVal { t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.DATA].GetTotalValue()) } + aSessions := make([]*ActiveSession, 0) + if err := smgRPC.Call("SMGenericV1.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &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", @@ -509,9 +544,14 @@ func TestSMGDataTTLExpiredMultiUpdates(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); err != nil { + t.Error(err) + } else if len(aSessions) != 0 { + t.Errorf("wrong active sessions: %+v", aSessions) + } } -func TestSMGDataLastUsedMultipleDataNoUsage(t *testing.T) { +func TestSMGDataMultipleDataNoUsage(t *testing.T) { if !*testIntegration { return } @@ -551,31 +591,11 @@ func TestSMGDataLastUsedMultipleDataNoUsage(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{ - utils.EVENT_NAME: "TEST_EVENT", - utils.TOR: utils.DATA, - utils.ACCID: "12349", - 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("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil { + aSessions := make([]*ActiveSession, 0) + if err := smgRPC.Call("SMGenericV1.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); 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()) + } 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", @@ -603,32 +623,10 @@ func TestSMGDataLastUsedMultipleDataNoUsage(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{ - utils.EVENT_NAME: "TEST_EVENT", - utils.TOR: utils.DATA, - utils.ACCID: "12349", - 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("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil { + if err := smgRPC.Call("SMGenericV1.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); 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()) + } 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", @@ -656,7 +654,73 @@ func TestSMGDataLastUsedMultipleDataNoUsage(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &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: "12349", + 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("SMGenericV1.SessionUpdate", 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &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: "12349", + 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("SMGenericV1.SessionUpdate", 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &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, @@ -680,9 +744,14 @@ func TestSMGDataLastUsedMultipleDataNoUsage(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); err != nil { + t.Error(err) + } else if len(aSessions) != 0 { + t.Errorf("wrong active sessions: %+v", aSessions) + } } -func TestSMGDataLastUsedMultipleDataConstantUsage(t *testing.T) { +func TestSMGDataMultipleDataConstantUsage(t *testing.T) { if !*testIntegration { return } @@ -722,57 +791,11 @@ func TestSMGDataLastUsedMultipleDataConstantUsage(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{ - utils.EVENT_NAME: "TEST_EVENT", - utils.TOR: utils.DATA, - utils.ACCID: "12349", - 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("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil { + aSessions := make([]*ActiveSession, 0) + if err := smgRPC.Call("SMGenericV1.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); 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()) - } - smgEv = SMGenericEvent{ - utils.EVENT_NAME: "TEST_EVENT", - utils.TOR: utils.DATA, - utils.ACCID: "12349", - 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("SMGenericV1.SessionUpdate", 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()) + } else if len(aSessions) != 1 || aSessions[0].Usage.Seconds() != 1048576 { + t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds()) } smgEv = SMGenericEvent{ @@ -801,6 +824,11 @@ func TestSMGDataLastUsedMultipleDataConstantUsage(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &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, @@ -827,7 +855,73 @@ func TestSMGDataLastUsedMultipleDataConstantUsage(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &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: "12349", + 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("SMGenericV1.SessionUpdate", 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &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: "12349", + 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("SMGenericV1.SessionUpdate", 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &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, @@ -851,4 +945,9 @@ func TestSMGDataLastUsedMultipleDataConstantUsage(t *testing.T) { } 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.ActiveSessions", utils.AttrSMGGetActiveSessions{}, &aSessions); err != nil { + t.Error(err) + } else if len(aSessions) != 0 { + t.Errorf("wrong active sessions: %f", aSessions[0].Usage.Seconds()) + } } diff --git a/sessionmanager/smg_session.go b/sessionmanager/smg_session.go index 79160139c..df622953b 100644 --- a/sessionmanager/smg_session.go +++ b/sessionmanager/smg_session.go @@ -113,6 +113,7 @@ func (self *SMGSession) debit(dur time.Duration, lastUsed *time.Duration) (time. self.cd.DurationIndex += dur cc := &engine.CallCost{} if err := self.rater.Call("Responder.MaxDebit", self.cd, cc); err != nil { + self.lastUsage = 0 self.lastDebit = 0 return 0, err } From d8e789c1a06d12ce659d2bdc16f97bba83507a30 Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Fri, 29 Apr 2016 18:50:12 +0300 Subject: [PATCH 06/11] fix GetActions test --- apier/v1/apier_local_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apier/v1/apier_local_test.go b/apier/v1/apier_local_test.go index 124b6a984..edfd7bd57 100644 --- a/apier/v1/apier_local_test.go +++ b/apier/v1/apier_local_test.go @@ -974,7 +974,7 @@ func TestApierGetActions(t *testing.T) { return } expectActs := []*utils.TPAction{ - &utils.TPAction{Identifier: engine.TOPUP_RESET, BalanceType: utils.MONETARY, Directions: utils.OUT, Units: "75", BalanceWeight: "0", BalanceBlocker: "false", BalanceDisabled: "false", ExpiryTime: engine.UNLIMITED, Weight: 20.0}} + &utils.TPAction{Identifier: engine.TOPUP_RESET, BalanceType: utils.MONETARY, Directions: utils.OUT, Units: "{\"Method\":\"\",\"Params\":null,\"Static\":75}", BalanceWeight: "0", BalanceBlocker: "false", BalanceDisabled: "false", ExpiryTime: engine.UNLIMITED, Weight: 20.0}} var reply []*utils.TPAction if err := rater.Call("ApierV1.GetActions", "ACTS_1", &reply); err != nil { From ac5fddd8ca83d80e0a0e1b2b8a5fdd8437e1e39c Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Fri, 29 Apr 2016 21:08:10 +0300 Subject: [PATCH 07/11] improved GetActions in ApierV2 (params changes!) --- apier/v1/apier.go | 2 +- apier/v2/accounts.go | 2 +- apier/v2/apier.go | 55 +++++++++++++++++++++++++++++ console/actions.go | 11 +++--- data/tariffplans/testtp/Actions.csv | 2 ++ engine/storage_interface.go | 1 + engine/tp_reader.go | 6 ++-- 7 files changed, 70 insertions(+), 9 deletions(-) diff --git a/apier/v1/apier.go b/apier/v1/apier.go index f65b3df94..6d489468d 100644 --- a/apier/v1/apier.go +++ b/apier/v1/apier.go @@ -572,7 +572,7 @@ func (self *ApierV1) GetActions(actsId string, reply *[]*utils.TPAction) error { bf := engAct.Balance if bf != nil { act.BalanceType = bf.GetType() - act.Units = bf.Value.String() + act.Units = strconv.FormatFloat(bf.GetValue(), 'f', -1, 64) act.Directions = bf.GetDirections().String() act.DestinationIds = bf.GetDestinationIDs().String() act.RatingSubject = bf.GetRatingSubject() diff --git a/apier/v2/accounts.go b/apier/v2/accounts.go index 08f6832dd..83d3d56f2 100644 --- a/apier/v2/accounts.go +++ b/apier/v2/accounts.go @@ -33,7 +33,7 @@ func (self *ApierV2) GetAccounts(attr utils.AttrGetAccounts, reply *[]*engine.Ac var accountKeys []string var err error if len(attr.AccountIds) == 0 { - if accountKeys, err = self.AccountDb.GetKeysForPrefix(utils.ACCOUNT_PREFIX+utils.ConcatenatedKey(attr.Tenant), true); err != nil { + if accountKeys, err = self.AccountDb.GetKeysForPrefix(utils.ACCOUNT_PREFIX+attr.Tenant, true); err != nil { return err } } else { diff --git a/apier/v2/apier.go b/apier/v2/apier.go index 9f5f4cc2a..4bf68bd4f 100644 --- a/apier/v2/apier.go +++ b/apier/v2/apier.go @@ -21,6 +21,7 @@ package v2 import ( "errors" "fmt" + "math" "os" "path" "strings" @@ -263,3 +264,57 @@ func (self *ApierV2) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder, *reply = *li return nil } + +type AttrGetActions struct { + ActionIDs []string + Offset int // Set the item offset + Limit int // Limit number of items retrieved +} + +// Retrieves actions attached to specific ActionsId within cache +func (self *ApierV2) GetActions(attr AttrGetActions, reply *map[string]engine.Actions) error { + var actionKeys []string + var err error + if len(attr.ActionIDs) == 0 { + if actionKeys, err = self.AccountDb.GetKeysForPrefix(utils.ACTION_PREFIX, false); err != nil { + return err + } + } else { + for _, accID := range attr.ActionIDs { + if len(accID) == 0 { // Source of error returned from redis (key not found) + continue + } + actionKeys = append(actionKeys, utils.ACCOUNT_PREFIX+accID) + } + } + if len(actionKeys) == 0 { + return nil + } + if attr.Offset > len(actionKeys) { + attr.Offset = len(actionKeys) + } + if attr.Offset < 0 { + attr.Offset = 0 + } + var limitedActions []string + if attr.Limit != 0 { + max := math.Min(float64(attr.Offset+attr.Limit), float64(len(actionKeys))) + limitedActions = actionKeys[attr.Offset:int(max)] + } else { + limitedActions = actionKeys[attr.Offset:] + } + retActions := make(map[string]engine.Actions) + for _, accKey := range limitedActions { + key := accKey[len(utils.ACTION_PREFIX):] + acts, err := self.RatingDb.GetActions(key, false) + if err != nil { + return utils.NewErrServerError(err) + } + if len(acts) > 0 { + retActions[key] = acts + + } + } + *reply = retActions + return nil +} diff --git a/console/actions.go b/console/actions.go index 25e9af0e5..1d2504029 100644 --- a/console/actions.go +++ b/console/actions.go @@ -18,7 +18,10 @@ along with this program. If not, see package console -import "github.com/cgrates/cgrates/utils" +import ( + "github.com/cgrates/cgrates/apier/v2" + "github.com/cgrates/cgrates/engine" +) func init() { c := &CmdGetActions{ @@ -33,7 +36,7 @@ func init() { type CmdGetActions struct { name string rpcMethod string - rpcParams *StringWrapper + rpcParams *v2.AttrGetActions *CommandExecuter } @@ -47,7 +50,7 @@ func (self *CmdGetActions) RpcMethod() string { func (self *CmdGetActions) RpcParams(reset bool) interface{} { if reset || self.rpcParams == nil { - self.rpcParams = &StringWrapper{} + self.rpcParams = &v2.AttrGetActions{} } return self.rpcParams } @@ -57,6 +60,6 @@ func (self *CmdGetActions) PostprocessRpcParams() error { } func (self *CmdGetActions) RpcResult() interface{} { - a := make([]*utils.TPAction, 0) + a := make(map[string]engine.Actions, 0) return &a } diff --git a/data/tariffplans/testtp/Actions.csv b/data/tariffplans/testtp/Actions.csv index 680866202..20d61a27d 100644 --- a/data/tariffplans/testtp/Actions.csv +++ b/data/tariffplans/testtp/Actions.csv @@ -10,3 +10,5 @@ TOPUP_DATA_r,*topup,,,,*data,*out,,DATA_DEST,datar,,*unlimited,,50000000000,10,f TOPUP_VOICE,*topup,,,,*voice,*out,,GERMANY_MOBILE,,,*unlimited,,50000,10,false,false,10 TOPUP_NEG,*topup,,,,*voice,*out,,GERMANY;!GERMANY_MOBILE,*zero1m,,*unlimited,,100,10,false,false,10 RPC,*cgr_rpc,"{""Address"": ""localhost:2013"",""Transport"":""*gob"",""Method"":""ApierV2.SetAccount"",""Attempts"":1,""Async"" :false,""Params"":{""Account"":""rpc"",""Tenant"":""cgrates.org""}}",,,,,,,,,,,,,,, +DID,*debit,,,,*monetary,*out,,*any,,,*unlimited,*any,"{""Method"":""*incremental"",""Params"":{""Units"":1, ""Interval"":""month"",""Increment"":""day""}}",10.0,,,10.0 +DID,*cdrlog,"{""action"":""^DID"",""prev_balance"":""BalanceValue""}",,,*monetary,*out,,*any,,,*unlimited,,,10.0,,,10.0 diff --git a/engine/storage_interface.go b/engine/storage_interface.go index 96a4b32c6..5fd6657db 100644 --- a/engine/storage_interface.go +++ b/engine/storage_interface.go @@ -204,6 +204,7 @@ func NewCodecMsgpackMarshaler() *CodecMsgpackMarshaler { cmm := &CodecMsgpackMarshaler{new(codec.MsgpackHandle)} mh := cmm.mh mh.MapType = reflect.TypeOf(map[string]interface{}(nil)) + mh.RawToString = true return cmm } diff --git a/engine/tp_reader.go b/engine/tp_reader.go index a2a71470b..4eaf2e81f 100644 --- a/engine/tp_reader.go +++ b/engine/tp_reader.go @@ -514,7 +514,7 @@ func (tpr *TpReader) LoadActions() (err error) { } } acts[idx] = &Action{ - Id: tag + strconv.Itoa(idx), + Id: tag, ActionType: tpact.Identifier, //BalanceType: tpact.BalanceType, Weight: tpact.Weight, @@ -990,7 +990,7 @@ func (tpr *TpReader) LoadAccountActionsFiltered(qriedAA *TpAccountAction) error } } acts[idx] = &Action{ - Id: tag + strconv.Itoa(idx), + Id: tag, ActionType: tpact.Identifier, //BalanceType: tpact.BalanceType, Weight: tpact.Weight, @@ -1338,7 +1338,7 @@ func (tpr *TpReader) LoadCdrStatsFiltered(tag string, save bool) (err error) { } } acts[idx] = &Action{ - Id: tag + strconv.Itoa(idx), + Id: tag, ActionType: tpact.Identifier, //BalanceType: tpact.BalanceType, Weight: tpact.Weight, From 114447d6d3a13c15398c82c4c7ea941924a408ae Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Fri, 29 Apr 2016 21:22:03 +0300 Subject: [PATCH 08/11] test fixes --- apier/v1/apier_local_test.go | 4 ++-- engine/loader_csv_test.go | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/apier/v1/apier_local_test.go b/apier/v1/apier_local_test.go index edfd7bd57..0e1e7f09e 100644 --- a/apier/v1/apier_local_test.go +++ b/apier/v1/apier_local_test.go @@ -974,7 +974,7 @@ func TestApierGetActions(t *testing.T) { return } expectActs := []*utils.TPAction{ - &utils.TPAction{Identifier: engine.TOPUP_RESET, BalanceType: utils.MONETARY, Directions: utils.OUT, Units: "{\"Method\":\"\",\"Params\":null,\"Static\":75}", BalanceWeight: "0", BalanceBlocker: "false", BalanceDisabled: "false", ExpiryTime: engine.UNLIMITED, Weight: 20.0}} + &utils.TPAction{Identifier: engine.TOPUP_RESET, BalanceType: utils.MONETARY, Directions: utils.OUT, Units: "75", BalanceWeight: "0", BalanceBlocker: "false", BalanceDisabled: "false", ExpiryTime: engine.UNLIMITED, Weight: 20.0}} var reply []*utils.TPAction if err := rater.Call("ApierV1.GetActions", "ACTS_1", &reply); err != nil { @@ -1297,7 +1297,7 @@ func TestApierResetDataAfterLoadFromFolder(t *testing.T) { if rcvStats.Destinations != 5 || rcvStats.RatingPlans != 5 || rcvStats.RatingProfiles != 5 || - rcvStats.Actions != 10 || + rcvStats.Actions != 11 || rcvStats.DerivedChargers != 3 { t.Errorf("Calling ApierV1.GetCacheStats received: %+v", rcvStats) } diff --git a/engine/loader_csv_test.go b/engine/loader_csv_test.go index f2fb1f898..fbcf9e8f2 100644 --- a/engine/loader_csv_test.go +++ b/engine/loader_csv_test.go @@ -833,7 +833,7 @@ func TestLoadActions(t *testing.T) { as1 := csvr.actions["MINI"] expected := []*Action{ &Action{ - Id: "MINI0", + Id: "MINI", ActionType: TOPUP_RESET, ExpirationString: UNLIMITED, ExtraParameters: "", @@ -853,7 +853,7 @@ func TestLoadActions(t *testing.T) { }, }, &Action{ - Id: "MINI1", + Id: "MINI", ActionType: TOPUP, ExpirationString: UNLIMITED, ExtraParameters: "", @@ -880,7 +880,7 @@ func TestLoadActions(t *testing.T) { as2 := csvr.actions["SHARED"] expected = []*Action{ &Action{ - Id: "SHARED0", + Id: "SHARED", ActionType: TOPUP, ExpirationString: UNLIMITED, Weight: 10, @@ -905,7 +905,7 @@ func TestLoadActions(t *testing.T) { as3 := csvr.actions["DEFEE"] expected = []*Action{ &Action{ - Id: "DEFEE0", + Id: "DEFEE", ActionType: CDRLOG, ExtraParameters: `{"Category":"^ddi","MediationRunId":"^did_run"}`, Weight: 10, From 0777c299b3c87bea75c131657345c8c0378ed949 Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Fri, 29 Apr 2016 22:26:05 +0300 Subject: [PATCH 09/11] started RemActions API --- apier/v1/apier.go | 45 ++++++++++++++++++++++++++++++++++ engine/storage_interface.go | 1 + engine/storage_map.go | 7 ++++++ engine/storage_mongo_datadb.go | 4 +++ engine/storage_redis.go | 5 ++++ 5 files changed, 62 insertions(+) diff --git a/apier/v1/apier.go b/apier/v1/apier.go index 6d489468d..1ca28e9a0 100644 --- a/apier/v1/apier.go +++ b/apier/v1/apier.go @@ -1064,3 +1064,48 @@ func (self *ApierV1) GetLoadHistory(attrs utils.Paginator, reply *[]*engine.Load *reply = loadHist[offset:nrItems] return nil } + +type AttrRemActions struct { + ActionIDs []string +} + +func (self *ApierV1) RemActions(attr AttrRemActions, reply *string) error { + if attr.ActionIDs == nil { + return nil + } + stringMap := utils.NewStringMap(attr.ActionIDs...) + keys, err := self.RatingDb.GetKeysForPrefix(utils.ACTION_TRIGGER_PREFIX, true) + if err != nil { + return err + } + for _, key := range keys { + getAttrs, err := self.RatingDb.GetActionTriggers(key[len(utils.ACTION_TRIGGER_PREFIX):]) + if err != nil { + return err + } + for _, atr := range getAttrs { + if _, found := stringMap[atr.ActionsID]; found { + // found action trigger referencing action; abort + return fmt.Errorf("action %s refenced by action trigger %s", atr.ActionsID, atr.ID) + } + } + } + allAplsMap, err := self.RatingDb.GetAllActionPlans() + if err != nil { + return err + } + for _, apl := range allAplsMap { + for _, aID := range attr.ActionIDs { + if _, found := apl.AccountIDs[aID]; found { + return fmt.Errorf("action %s refenced by action plan %s", aID, apl.Id) + } + } + + } + for _, aID := range attr.ActionIDs { + if err := self.RatingDb.RemoveActions(aID); err != nil { + return err + } + } + return nil +} diff --git a/engine/storage_interface.go b/engine/storage_interface.go index 5fd6657db..327be197f 100644 --- a/engine/storage_interface.go +++ b/engine/storage_interface.go @@ -59,6 +59,7 @@ type RatingStorage interface { SetDerivedChargers(string, *utils.DerivedChargers) error GetActions(string, bool) (Actions, error) SetActions(string, Actions) error + RemoveActions(string) error GetSharedGroup(string, bool) (*SharedGroup, error) SetSharedGroup(*SharedGroup) error GetActionTriggers(string) (ActionTriggers, error) diff --git a/engine/storage_map.go b/engine/storage_map.go index afab1a06d..f9a747a5b 100644 --- a/engine/storage_map.go +++ b/engine/storage_map.go @@ -469,6 +469,13 @@ func (ms *MapStorage) SetActions(key string, as Actions) (err error) { return } +func (ms *MapStorage) RemoveActions(key string) (err error) { + ms.mu.Lock() + defer ms.mu.Unlock() + delete(ms.dict, utils.ACTION_PREFIX+key) + return +} + func (ms *MapStorage) GetSharedGroup(key string, skipCache bool) (sg *SharedGroup, err error) { ms.mu.RLock() defer ms.mu.RUnlock() diff --git a/engine/storage_mongo_datadb.go b/engine/storage_mongo_datadb.go index 0e2e59113..70fc91dc4 100644 --- a/engine/storage_mongo_datadb.go +++ b/engine/storage_mongo_datadb.go @@ -916,6 +916,10 @@ func (ms *MongoStorage) SetActions(key string, as Actions) error { return err } +func (ms *MongoStorage) RemoveActions(key string) error { + return ms.db.C(colAct).Remove(bson.M{"key": key}) +} + func (ms *MongoStorage) GetSharedGroup(key string, skipCache bool) (sg *SharedGroup, err error) { if !skipCache { if x, err := cache2go.Get(utils.SHARED_GROUP_PREFIX + key); err == nil { diff --git a/engine/storage_redis.go b/engine/storage_redis.go index 896181922..be591ff48 100644 --- a/engine/storage_redis.go +++ b/engine/storage_redis.go @@ -590,6 +590,11 @@ func (rs *RedisStorage) SetActions(key string, as Actions) (err error) { return } +func (rs *RedisStorage) RemoveActions(key string) (err error) { + err = rs.db.Cmd("DEL", utils.ACTION_PREFIX+key).Err + return +} + func (rs *RedisStorage) GetSharedGroup(key string, skipCache bool) (sg *SharedGroup, err error) { key = utils.SHARED_GROUP_PREFIX + key if !skipCache { From ce04b07a43c065d834079644b3c2bba723a5635d Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Sat, 30 Apr 2016 13:50:09 +0300 Subject: [PATCH 10/11] console command and test for RemActions --- apier/v1/apier.go | 29 +++++++++++---- apier/v2/apier.go | 1 + console/actions_remove.go | 62 ++++++++++++++++++++++++++++++++ general_tests/tp_it_test.go | 71 +++++++++++++++++++++++++++++++++++++ 4 files changed, 156 insertions(+), 7 deletions(-) create mode 100644 console/actions_remove.go diff --git a/apier/v1/apier.go b/apier/v1/apier.go index 1ca28e9a0..21d64d422 100644 --- a/apier/v1/apier.go +++ b/apier/v1/apier.go @@ -523,7 +523,7 @@ func (self *ApierV1) SetActions(attrs utils.AttrSetActions, reply *string) error } a := &engine.Action{ - Id: utils.GenUUID(), + Id: attrs.ActionsId, ActionType: apiAct.Identifier, Weight: apiAct.Weight, ExpirationString: apiAct.ExpiryTime, @@ -1071,41 +1071,56 @@ type AttrRemActions struct { func (self *ApierV1) RemActions(attr AttrRemActions, reply *string) error { if attr.ActionIDs == nil { - return nil + err := utils.ErrNotFound + *reply = err.Error() + return err } stringMap := utils.NewStringMap(attr.ActionIDs...) keys, err := self.RatingDb.GetKeysForPrefix(utils.ACTION_TRIGGER_PREFIX, true) if err != nil { + *reply = err.Error() return err } for _, key := range keys { getAttrs, err := self.RatingDb.GetActionTriggers(key[len(utils.ACTION_TRIGGER_PREFIX):]) if err != nil { + *reply = err.Error() return err } for _, atr := range getAttrs { if _, found := stringMap[atr.ActionsID]; found { // found action trigger referencing action; abort - return fmt.Errorf("action %s refenced by action trigger %s", atr.ActionsID, atr.ID) + err := fmt.Errorf("action %s refenced by action trigger %s", atr.ActionsID, atr.ID) + *reply = err.Error() + return err } } } allAplsMap, err := self.RatingDb.GetAllActionPlans() - if err != nil { + if err != nil && err != utils.ErrNotFound { + *reply = err.Error() return err } for _, apl := range allAplsMap { - for _, aID := range attr.ActionIDs { - if _, found := apl.AccountIDs[aID]; found { - return fmt.Errorf("action %s refenced by action plan %s", aID, apl.Id) + for _, atm := range apl.ActionTimings { + if _, found := stringMap[atm.ActionsID]; found { + err := fmt.Errorf("action %s refenced by action plan %s", atm.ActionsID, apl.Id) + *reply = err.Error() + return err } } } for _, aID := range attr.ActionIDs { if err := self.RatingDb.RemoveActions(aID); err != nil { + *reply = err.Error() return err } } + if err := self.RatingDb.CacheRatingPrefixes(utils.ACTION_PREFIX); err != nil { + *reply = err.Error() + return err + } + *reply = utils.OK return nil } diff --git a/apier/v2/apier.go b/apier/v2/apier.go index 4bf68bd4f..e337400b0 100644 --- a/apier/v2/apier.go +++ b/apier/v2/apier.go @@ -315,6 +315,7 @@ func (self *ApierV2) GetActions(attr AttrGetActions, reply *map[string]engine.Ac } } + *reply = retActions return nil } diff --git a/console/actions_remove.go b/console/actions_remove.go new file mode 100644 index 000000000..c7d5f54db --- /dev/null +++ b/console/actions_remove.go @@ -0,0 +1,62 @@ +/* +Real-time Charging System for Telecom & ISP environments +Copyright (C) 2012-2015 ITsysCOM GmbH + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see +*/ + +package console + +import "github.com/cgrates/cgrates/apier/v1" + +func init() { + c := &CmdRemoveActions{ + name: "actions_remove", + rpcMethod: "ApierV1.RemActions", + } + commands[c.Name()] = c + c.CommandExecuter = &CommandExecuter{c} +} + +// Commander implementation +type CmdRemoveActions struct { + name string + rpcMethod string + rpcParams *v1.AttrRemActions + *CommandExecuter +} + +func (self *CmdRemoveActions) Name() string { + return self.name +} + +func (self *CmdRemoveActions) RpcMethod() string { + return self.rpcMethod +} + +func (self *CmdRemoveActions) RpcParams(reset bool) interface{} { + if reset || self.rpcParams == nil { + self.rpcParams = &v1.AttrRemActions{} + } + return self.rpcParams +} + +func (self *CmdRemoveActions) PostprocessRpcParams() error { + return nil +} + +func (self *CmdRemoveActions) RpcResult() interface{} { + var s string + return &s +} diff --git a/general_tests/tp_it_test.go b/general_tests/tp_it_test.go index bb7560921..723ebda93 100644 --- a/general_tests/tp_it_test.go +++ b/general_tests/tp_it_test.go @@ -8,6 +8,7 @@ import ( "time" "github.com/cgrates/cgrates/apier/v1" + "github.com/cgrates/cgrates/apier/v2" "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/engine" "github.com/cgrates/cgrates/utils" @@ -291,3 +292,73 @@ func TestTpCreateExecuteActionMatch(t *testing.T) { t.Error("error matching previous created balance: ", utils.ToIJSON(acnt.BalanceMap)) } } + +func TestTpSetRemActions(t *testing.T) { + if !*testIntegration { + return + } + var reply string + if err := tpRPC.Call("ApierV2.SetActions", utils.AttrSetActions{ + ActionsId: "TO_BE_DELETED", + Actions: []*utils.TPAction{ + &utils.TPAction{ + BalanceType: "*monetary", + Directions: "*out", + Identifier: "*topup", + RatingSubject: "", + Units: "10.500000", + Weight: 10, + }, + }, + }, &reply); err != nil { + t.Error("Got error on ApierV2.SetActions: ", err.Error()) + } else if reply != utils.OK { + t.Errorf("Calling ApierV2.SetActions got reply: %s", reply) + } + actionsMap := make(map[string]engine.Actions) + if err := tpRPC.Call("ApierV2.GetActions", v2.AttrGetActions{ + ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"}, + }, &actionsMap); err != nil { + t.Error("Got error on ApierV2.GetActions: ", err.Error()) + } else if len(actionsMap) != 1 { + t.Errorf("Calling ApierV2.GetActions got reply: %s", utils.ToIJSON(actionsMap)) + } + if err := tpRPC.Call("ApierV2.RemActions", v1.AttrRemActions{ + ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"}, + }, &reply); err != nil { + t.Error("Got error on ApierV2.RemActions: ", err.Error()) + } else if reply != utils.OK { + t.Errorf("Calling ApierV2.RemActions got reply: %s", reply) + } + if err := tpRPC.Call("ApierV2.GetActions", v2.AttrGetActions{ + ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"}, + }, &actionsMap); err == nil { + t.Error("no error on ApierV2.GetActions: ", err) + } +} + +func TestTpRemActionsRefenced(t *testing.T) { + actionsMap := make(map[string]engine.Actions) + if err := tpRPC.Call("ApierV2.GetActions", v2.AttrGetActions{ + ActionIDs: []string{"TOPUP_VOICE"}, + }, &actionsMap); err != nil { + t.Error("Got error on ApierV2.GetActions: ", err.Error()) + } else if len(actionsMap) != 1 { + t.Errorf("Calling ApierV2.GetActions got reply: %s", utils.ToIJSON(actionsMap)) + } + var reply string + if err := tpRPC.Call("ApierV2.RemActions", v1.AttrRemActions{ + ActionIDs: []string{"TOPUP_VOICE"}, + }, &reply); err == nil { + t.Error("No error on ApierV2.RemActions: ", err.Error()) + } else if reply == utils.OK { + t.Errorf("Calling ApierV2.RemActions got reply: %s", reply) + } + if err := tpRPC.Call("ApierV2.GetActions", v2.AttrGetActions{ + ActionIDs: []string{"TOPUP_VOICE"}, + }, &actionsMap); err != nil { + t.Error("Got error on ApierV2.GetActions: ", err.Error()) + } else if len(actionsMap) != 1 { + t.Errorf("Calling ApierV2.GetActions got reply: %s", utils.ToIJSON(actionsMap)) + } +} From e96f5e34b0866bdb4b3b33d365aefc1f79f80058 Mon Sep 17 00:00:00 2001 From: Radu Ioan Fericean Date: Sat, 30 Apr 2016 14:03:49 +0300 Subject: [PATCH 11/11] fixed test and removed pprof --- cmd/cgr-engine/cgr-engine.go | 2 +- general_tests/tp_it_test.go | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/cmd/cgr-engine/cgr-engine.go b/cmd/cgr-engine/cgr-engine.go index c342e56ba..ddf5b3b14 100644 --- a/cmd/cgr-engine/cgr-engine.go +++ b/cmd/cgr-engine/cgr-engine.go @@ -22,7 +22,7 @@ import ( "flag" "fmt" "log" - _ "net/http/pprof" + // _ "net/http/pprof" "os" "runtime" "runtime/pprof" diff --git a/general_tests/tp_it_test.go b/general_tests/tp_it_test.go index 723ebda93..a917c9961 100644 --- a/general_tests/tp_it_test.go +++ b/general_tests/tp_it_test.go @@ -338,6 +338,9 @@ func TestTpSetRemActions(t *testing.T) { } func TestTpRemActionsRefenced(t *testing.T) { + if !*testIntegration { + return + } actionsMap := make(map[string]engine.Actions) if err := tpRPC.Call("ApierV2.GetActions", v2.AttrGetActions{ ActionIDs: []string{"TOPUP_VOICE"},