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

Commented tests in general tests for now

Browse Source
This commit is contained in:
andronache
2021-09-24 17:40:34 +03:00
committed by Dan Christian Bogos
parent 323fa2389c
commit be55e28eb2
51 changed files with 19872 additions and 20159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

700
general_tests/a1_it_test.go
View File

@@ -20,379 +20,379 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"encoding/json"
"fmt"
"net/rpc"
"path"
"sync"
"testing"
"time"
// import (
// "encoding/json"
// "fmt"
// "net/rpc"
// "path"
// "sync"
// "testing"
// "time"
"github.com/cgrates/birpc/context"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/birpc/context"
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// )
var (
a1ConfigDir string
a1CfgPath string
a1Cfg *config.CGRConfig
a1rpc *rpc.Client
// var (
// a1ConfigDir string
// a1CfgPath string
// a1Cfg *config.CGRConfig
// a1rpc *rpc.Client
sTestsA1it = []func(t *testing.T){
testA1itLoadConfig,
testA1itResetDataDB,
testA1itResetStorDb,
testA1itStartEngine,
testA1itRPCConn,
testA1itLoadTPFromFolder,
testA1itAddBalance1,
testA1itDataSession1,
testA1itConcurrentAPs,
testA1itStopCgrEngine,
}
)
// sTestsA1it = []func(t *testing.T){
// testA1itLoadConfig,
// testA1itResetDataDB,
// testA1itResetStorDb,
// testA1itStartEngine,
// testA1itRPCConn,
// testA1itLoadTPFromFolder,
// testA1itAddBalance1,
// testA1itDataSession1,
// testA1itConcurrentAPs,
// testA1itStopCgrEngine,
// }
// )
func TestA1It(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
a1ConfigDir = "tutinternal"
case utils.MetaMySQL:
a1ConfigDir = "tutmysql"
case utils.MetaMongo:
a1ConfigDir = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
// func TestA1It(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// a1ConfigDir = "tutinternal"
// case utils.MetaMySQL:
// a1ConfigDir = "tutmysql"
// case utils.MetaMongo:
// a1ConfigDir = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
for _, stest := range sTestsA1it {
t.Run(a1ConfigDir, stest)
}
}
// for _, stest := range sTestsA1it {
// t.Run(a1ConfigDir, stest)
// }
// }
func testA1itLoadConfig(t *testing.T) {
a1CfgPath = path.Join(*dataDir, "conf", "samples", a1ConfigDir)
if a1Cfg, err = config.NewCGRConfigFromPath(context.Background(), a1CfgPath); err != nil {
t.Error(err)
}
}
// func testA1itLoadConfig(t *testing.T) {
// a1CfgPath = path.Join(*dataDir, "conf", "samples", a1ConfigDir)
// if a1Cfg, err = config.NewCGRConfigFromPath(context.Background(), a1CfgPath); err != nil {
// t.Error(err)
// }
// }
func testA1itResetDataDB(t *testing.T) {
if err := engine.InitDataDB(a1Cfg); err != nil {
t.Fatal(err)
}
}
// func testA1itResetDataDB(t *testing.T) {
// if err := engine.InitDataDB(a1Cfg); err != nil {
// t.Fatal(err)
// }
// }
func testA1itResetStorDb(t *testing.T) {
if err := engine.InitStorDB(a1Cfg); err != nil {
t.Fatal(err)
}
}
// func testA1itResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(a1Cfg); err != nil {
// t.Fatal(err)
// }
// }
func testA1itStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(a1CfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testA1itStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(a1CfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testA1itRPCConn(t *testing.T) {
var err error
a1rpc, err = newRPCClient(a1Cfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testA1itRPCConn(t *testing.T) {
// var err error
// a1rpc, err = newRPCClient(a1Cfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testA1itLoadTPFromFolder(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "a1")}
if err := a1rpc.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error(reply)
}
time.Sleep(100 * time.Millisecond)
tStart := time.Date(2017, 3, 3, 10, 39, 33, 0, time.UTC)
tEnd := time.Date(2017, 3, 3, 10, 39, 33, 10240, time.UTC)
cd := &engine.CallDescriptorWithAPIOpts{
CallDescriptor: &engine.CallDescriptor{
Category: "data1",
Tenant: "cgrates.org",
Subject: "rpdata1",
Destination: "data",
TimeStart: tStart,
TimeEnd: tEnd,
},
}
var cc engine.CallCost
if err := a1rpc.Call(utils.ResponderGetCost, cd, &cc); err != nil {
t.Error("Got error on Responder.GetCost: ", err.Error())
} else if cc.Cost != 0.0 {
t.Errorf("Calling Responder.GetCost got callcost: %v", cc)
}
// func testA1itLoadTPFromFolder(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "a1")}
// if err := a1rpc.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error(reply)
// }
// time.Sleep(100 * time.Millisecond)
// tStart := time.Date(2017, 3, 3, 10, 39, 33, 0, time.UTC)
// tEnd := time.Date(2017, 3, 3, 10, 39, 33, 10240, time.UTC)
// cd := &engine.CallDescriptorWithAPIOpts{
// CallDescriptor: &engine.CallDescriptor{
// Category: "data1",
// Tenant: "cgrates.org",
// Subject: "rpdata1",
// Destination: "data",
// TimeStart: tStart,
// TimeEnd: tEnd,
// },
// }
// var cc engine.CallCost
// if err := a1rpc.Call(utils.ResponderGetCost, cd, &cc); err != nil {
// t.Error("Got error on Responder.GetCost: ", err.Error())
// } else if cc.Cost != 0.0 {
// t.Errorf("Calling Responder.GetCost got callcost: %v", cc)
// }
//add a default charger
chargerProfile := &v1.ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "Default",
RunID: utils.MetaDefault,
AttributeIDs: []string{"*none"},
Weight: 20,
},
}
var result string
if err := a1rpc.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
}
// //add a default charger
// chargerProfile := &v1.ChargerWithAPIOpts{
// ChargerProfile: &engine.ChargerProfile{
// Tenant: "cgrates.org",
// ID: "Default",
// RunID: utils.MetaDefault,
// AttributeIDs: []string{"*none"},
// Weight: 20,
// },
// }
// var result string
// if err := a1rpc.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
// }
func testA1itAddBalance1(t *testing.T) {
var reply string
argAdd := &v1.AttrAddBalance{
Tenant: "cgrates.org",
Account: "rpdata1",
BalanceType: utils.MetaData,
Value: 10000000000,
Balance: map[string]interface{}{
utils.ID: "rpdata1_test",
},
}
if err := a1rpc.Call(utils.APIerSv1AddBalance, argAdd, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf(reply)
}
argGet := &utils.AttrGetAccount{Tenant: argAdd.Tenant, Account: argAdd.Account}
var acnt *engine.Account
if err := a1rpc.Call(utils.APIerSv2GetAccount, argGet, &acnt); err != nil {
t.Error(err)
} else {
if acnt.BalanceMap[utils.MetaData].GetTotalValue() != argAdd.Value { // We expect 11.5 since we have added in the previous test 1.5
t.Errorf("Received account value: %f", acnt.BalanceMap[utils.MetaData].GetTotalValue())
}
}
}
// func testA1itAddBalance1(t *testing.T) {
// var reply string
// argAdd := &v1.AttrAddBalance{
// Tenant: "cgrates.org",
// Account: "rpdata1",
// BalanceType: utils.MetaData,
// Value: 10000000000,
// Balance: map[string]interface{}{
// utils.ID: "rpdata1_test",
// },
// }
// if err := a1rpc.Call(utils.APIerSv1AddBalance, argAdd, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf(reply)
// }
// argGet := &utils.AttrGetAccount{Tenant: argAdd.Tenant, Account: argAdd.Account}
// var acnt *engine.Account
// if err := a1rpc.Call(utils.APIerSv2GetAccount, argGet, &acnt); err != nil {
// t.Error(err)
// } else {
// if acnt.BalanceMap[utils.MetaData].GetTotalValue() != argAdd.Value { // We expect 11.5 since we have added in the previous test 1.5
// t.Errorf("Received account value: %f", acnt.BalanceMap[utils.MetaData].GetTotalValue())
// }
// }
// }
func testA1itDataSession1(t *testing.T) {
usage := time.Duration(10240)
initArgs := &sessions.V1InitSessionArgs{
InitSession: true,
// func testA1itDataSession1(t *testing.T) {
// usage := time.Duration(10240)
// initArgs := &sessions.V1InitSessionArgs{
// InitSession: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestA1itDataSession1",
Event: map[string]interface{}{
utils.EventName: "INITIATE_SESSION",
utils.ToR: utils.MetaData,
utils.OriginID: "504966119",
utils.AccountField: "rpdata1",
utils.Subject: "rpdata1",
utils.Destination: "data",
utils.Category: "data1",
utils.Tenant: "cgrates.org",
utils.RequestType: utils.MetaPrepaid,
utils.SetupTime: "2017-03-03 11:39:32 +0100 CET",
utils.AnswerTime: "2017-03-03 11:39:32 +0100 CET",
utils.Usage: "10240",
},
APIOpts: map[string]interface{}{
utils.OptsSesTTL: "28800s",
utils.OptsSesTTLLastUsed: "0s",
utils.OptsSesTTLUsage: "0s",
},
},
}
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestA1itDataSession1",
// Event: map[string]interface{}{
// utils.EventName: "INITIATE_SESSION",
// utils.ToR: utils.MetaData,
// utils.OriginID: "504966119",
// utils.AccountField: "rpdata1",
// utils.Subject: "rpdata1",
// utils.Destination: "data",
// utils.Category: "data1",
// utils.Tenant: "cgrates.org",
// utils.RequestType: utils.MetaPrepaid,
// utils.SetupTime: "2017-03-03 11:39:32 +0100 CET",
// utils.AnswerTime: "2017-03-03 11:39:32 +0100 CET",
// utils.Usage: "10240",
// },
// APIOpts: map[string]interface{}{
// utils.OptsSesTTL: "28800s",
// utils.OptsSesTTLLastUsed: "0s",
// utils.OptsSesTTLUsage: "0s",
// },
// },
// }
var initRpl *sessions.V1InitSessionReply
if err := a1rpc.Call(utils.SessionSv1InitiateSession,
initArgs, &initRpl); err != nil {
t.Fatal(err)
}
if initRpl.MaxUsage == nil || *initRpl.MaxUsage != usage {
t.Errorf("Expecting : %+v, received: %+v", usage, initRpl.MaxUsage)
}
// var initRpl *sessions.V1InitSessionReply
// if err := a1rpc.Call(utils.SessionSv1InitiateSession,
// initArgs, &initRpl); err != nil {
// t.Fatal(err)
// }
// if initRpl.MaxUsage == nil || *initRpl.MaxUsage != usage {
// t.Errorf("Expecting : %+v, received: %+v", usage, initRpl.MaxUsage)
// }
updateArgs := &sessions.V1UpdateSessionArgs{
UpdateSession: true,
// updateArgs := &sessions.V1UpdateSessionArgs{
// UpdateSession: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSessionsVoiceLastUsed",
Event: map[string]interface{}{
utils.EventName: "UPDATE_SESSION",
utils.AccountField: "rpdata1",
utils.Category: "data1",
utils.Destination: "data",
utils.InitialOriginID: "504966119",
utils.LastUsed: "0s",
utils.OriginID: "504966119-1",
utils.RequestType: utils.MetaPrepaid,
utils.Subject: "rpdata1",
utils.Tenant: "cgrates.org",
utils.ToR: utils.MetaData,
utils.SetupTime: "2017-03-03 11:39:32 +0100 CET",
utils.AnswerTime: "2017-03-03 11:39:32 +0100 CET",
utils.Usage: "2097152",
},
APIOpts: map[string]interface{}{
utils.OptsSesTTL: "28800s",
utils.OptsSesTTLLastUsed: "2097152s",
utils.OptsSesTTLUsage: "0s",
},
},
}
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSessionsVoiceLastUsed",
// Event: map[string]interface{}{
// utils.EventName: "UPDATE_SESSION",
// utils.AccountField: "rpdata1",
// utils.Category: "data1",
// utils.Destination: "data",
// utils.InitialOriginID: "504966119",
// utils.LastUsed: "0s",
// utils.OriginID: "504966119-1",
// utils.RequestType: utils.MetaPrepaid,
// utils.Subject: "rpdata1",
// utils.Tenant: "cgrates.org",
// utils.ToR: utils.MetaData,
// utils.SetupTime: "2017-03-03 11:39:32 +0100 CET",
// utils.AnswerTime: "2017-03-03 11:39:32 +0100 CET",
// utils.Usage: "2097152",
// },
// APIOpts: map[string]interface{}{
// utils.OptsSesTTL: "28800s",
// utils.OptsSesTTLLastUsed: "2097152s",
// utils.OptsSesTTLUsage: "0s",
// },
// },
// }
usage = 2097152
var updateRpl *sessions.V1UpdateSessionReply
if err := a1rpc.Call(utils.SessionSv1UpdateSession, updateArgs, &updateRpl); err != nil {
t.Error(err)
}
if updateRpl.MaxUsage == nil || *updateRpl.MaxUsage != usage {
t.Errorf("Expected: %+v, received: %+v", usage, updateRpl.MaxUsage)
}
// usage = 2097152
// var updateRpl *sessions.V1UpdateSessionReply
// if err := a1rpc.Call(utils.SessionSv1UpdateSession, updateArgs, &updateRpl); err != nil {
// t.Error(err)
// }
// if updateRpl.MaxUsage == nil || *updateRpl.MaxUsage != usage {
// t.Errorf("Expected: %+v, received: %+v", usage, updateRpl.MaxUsage)
// }
usage = time.Minute
termArgs := &sessions.V1TerminateSessionArgs{
TerminateSession: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSessionsVoiceLastUsed",
Event: map[string]interface{}{
utils.EventName: "TERMINATE_SESSION",
utils.AccountField: "rpdata1",
utils.Category: "data1",
utils.Destination: "data",
utils.LastUsed: "2202800",
utils.OriginID: "504966119-1",
utils.OriginIDPrefix: "504966119-1",
utils.RequestType: utils.MetaPrepaid,
utils.SetupTime: "2017-03-03 11:39:32 +0100 CET",
utils.AnswerTime: "2017-03-03 11:39:32 +0100 CET",
utils.Subject: "rpdata1",
utils.Tenant: "cgrates.org",
utils.ToR: utils.MetaData,
},
},
}
// usage = time.Minute
// termArgs := &sessions.V1TerminateSessionArgs{
// TerminateSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSessionsVoiceLastUsed",
// Event: map[string]interface{}{
// utils.EventName: "TERMINATE_SESSION",
// utils.AccountField: "rpdata1",
// utils.Category: "data1",
// utils.Destination: "data",
// utils.LastUsed: "2202800",
// utils.OriginID: "504966119-1",
// utils.OriginIDPrefix: "504966119-1",
// utils.RequestType: utils.MetaPrepaid,
// utils.SetupTime: "2017-03-03 11:39:32 +0100 CET",
// utils.AnswerTime: "2017-03-03 11:39:32 +0100 CET",
// utils.Subject: "rpdata1",
// utils.Tenant: "cgrates.org",
// utils.ToR: utils.MetaData,
// },
// },
// }
var rpl string
if err := a1rpc.Call(utils.SessionSv1TerminateSession, termArgs, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
// var rpl string
// if err := a1rpc.Call(utils.SessionSv1TerminateSession, termArgs, &rpl); err != nil || rpl != utils.OK {
// t.Error(err)
// }
if err := a1rpc.Call(utils.SessionSv1ProcessCDR, termArgs.CGREvent, &rpl); err != nil {
t.Error(err)
} else if rpl != utils.OK {
t.Errorf("Received reply: %s", rpl)
}
// if err := a1rpc.Call(utils.SessionSv1ProcessCDR, termArgs.CGREvent, &rpl); err != nil {
// t.Error(err)
// } else if rpl != utils.OK {
// t.Errorf("Received reply: %s", rpl)
// }
time.Sleep(20 * time.Millisecond)
// time.Sleep(20 * time.Millisecond)
var cdrs []*engine.ExternalCDR
req := utils.RPCCDRsFilter{RunIDs: []string{utils.MetaDefault}}
if err := a1rpc.Call(utils.APIerSv2GetCDRs, &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 != "2202800" {
t.Errorf("Unexpected CDR Usage received, cdr: %+v ", cdrs[0])
}
var cc engine.CallCost
var ec engine.EventCost
if err := json.Unmarshal([]byte(cdrs[0].CostDetails), &ec); err != nil {
t.Error(err)
}
cc = *ec.AsCallCost(utils.EmptyString)
if len(cc.Timespans) != 1 {
t.Errorf("Unexpected number of timespans: %+v, for %+v\n from:%+v", len(cc.Timespans), utils.ToJSON(cc.Timespans), utils.ToJSON(ec))
}
if cc.RatedUsage != 2202800 {
t.Errorf("RatingUsage expected: %f received %f, callcost: %+v ", 2202800.0, cc.RatedUsage, cc)
}
}
expBalance := float64(10000000000 - 2202800) // initial - total usage
var acnt *engine.Account
if err := a1rpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "rpdata1"}, &acnt); err != nil {
t.Error(err)
} else if acnt.BalanceMap[utils.MetaData].GetTotalValue() != expBalance { // We expect 11.5 since we have added in the previous test 1.5
t.Errorf("Expecting: %f, received: %f", expBalance, acnt.BalanceMap[utils.MetaData].GetTotalValue())
}
}
// var cdrs []*engine.ExternalCDR
// req := utils.RPCCDRsFilter{RunIDs: []string{utils.MetaDefault}}
// if err := a1rpc.Call(utils.APIerSv2GetCDRs, &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 != "2202800" {
// t.Errorf("Unexpected CDR Usage received, cdr: %+v ", cdrs[0])
// }
// var cc engine.CallCost
// var ec engine.EventCost
// if err := json.Unmarshal([]byte(cdrs[0].CostDetails), &ec); err != nil {
// t.Error(err)
// }
// cc = *ec.AsCallCost(utils.EmptyString)
// if len(cc.Timespans) != 1 {
// t.Errorf("Unexpected number of timespans: %+v, for %+v\n from:%+v", len(cc.Timespans), utils.ToJSON(cc.Timespans), utils.ToJSON(ec))
// }
// if cc.RatedUsage != 2202800 {
// t.Errorf("RatingUsage expected: %f received %f, callcost: %+v ", 2202800.0, cc.RatedUsage, cc)
// }
// }
// expBalance := float64(10000000000 - 2202800) // initial - total usage
// var acnt *engine.Account
// if err := a1rpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "rpdata1"}, &acnt); err != nil {
// t.Error(err)
// } else if acnt.BalanceMap[utils.MetaData].GetTotalValue() != expBalance { // We expect 11.5 since we have added in the previous test 1.5
// t.Errorf("Expecting: %f, received: %f", expBalance, acnt.BalanceMap[utils.MetaData].GetTotalValue())
// }
// }
func testA1itConcurrentAPs(t *testing.T) {
var wg sync.WaitGroup
var acnts []string
for i := 0; i < 1000; i++ {
acnts = append(acnts, fmt.Sprintf("acnt_%d", i))
}
// Set initial action plans
for _, acnt := range acnts {
wg.Add(1)
go func(acnt string) {
attrSetAcnt := v2.AttrSetAccount{
Tenant: "cgrates.org",
Account: acnt,
ActionPlanIDs: []string{"PACKAGE_1"},
}
var reply string
if err := a1rpc.Call(utils.APIerSv2SetAccount, &attrSetAcnt, &reply); err != nil {
t.Error(err)
}
wg.Done()
}(acnt)
}
wg.Wait()
// Make sure action plan was properly set
var aps []*engine.ActionPlan
if err := a1rpc.Call(utils.APIerSv1GetActionPlan, &v1.AttrGetActionPlan{ID: "PACKAGE_1"}, &aps); err != nil {
t.Error(err)
} else if len(aps[0].AccountIDs.Slice()) != len(acnts) {
t.Errorf("Received: %+v", aps[0])
}
// Change offer
for _, acnt := range acnts {
wg.Add(3)
go func(acnt string) {
attrSetAcnt := v2.AttrSetAccount{
Tenant: "cgrates.org",
Account: acnt,
ActionPlanIDs: []string{"PACKAGE_2"},
}
var reply string
if err := a1rpc.Call(utils.APIerSv2SetAccount, &attrSetAcnt, &reply); err != nil {
t.Error(err)
}
wg.Done()
}(acnt)
}
wg.Wait()
// Make sure action plan was properly rem/set
aps = []*engine.ActionPlan{}
if err := a1rpc.Call(utils.APIerSv1GetActionPlan, &v1.AttrGetActionPlan{ID: "PACKAGE_1"}, &aps); err != nil {
t.Error(err)
} else if len(aps[0].AccountIDs.Slice()) != 0 {
t.Errorf("Received: %+v", aps[0])
}
aps = []*engine.ActionPlan{}
if err := a1rpc.Call(utils.APIerSv1GetActionPlan, &v1.AttrGetActionPlan{ID: "PACKAGE_2"}, &aps); err != nil {
t.Error(err)
} else if len(aps[0].AccountIDs.Slice()) != len(acnts) {
t.Errorf("Received: %+v", aps[0])
}
}
// func testA1itConcurrentAPs(t *testing.T) {
// var wg sync.WaitGroup
// var acnts []string
// for i := 0; i < 1000; i++ {
// acnts = append(acnts, fmt.Sprintf("acnt_%d", i))
// }
// // Set initial action plans
// for _, acnt := range acnts {
// wg.Add(1)
// go func(acnt string) {
// attrSetAcnt := v2.AttrSetAccount{
// Tenant: "cgrates.org",
// Account: acnt,
// ActionPlanIDs: []string{"PACKAGE_1"},
// }
// var reply string
// if err := a1rpc.Call(utils.APIerSv2SetAccount, &attrSetAcnt, &reply); err != nil {
// t.Error(err)
// }
// wg.Done()
// }(acnt)
// }
// wg.Wait()
// // Make sure action plan was properly set
// var aps []*engine.ActionPlan
// if err := a1rpc.Call(utils.APIerSv1GetActionPlan, &v1.AttrGetActionPlan{ID: "PACKAGE_1"}, &aps); err != nil {
// t.Error(err)
// } else if len(aps[0].AccountIDs.Slice()) != len(acnts) {
// t.Errorf("Received: %+v", aps[0])
// }
// // Change offer
// for _, acnt := range acnts {
// wg.Add(3)
// go func(acnt string) {
// attrSetAcnt := v2.AttrSetAccount{
// Tenant: "cgrates.org",
// Account: acnt,
// ActionPlanIDs: []string{"PACKAGE_2"},
// }
// var reply string
// if err := a1rpc.Call(utils.APIerSv2SetAccount, &attrSetAcnt, &reply); err != nil {
// t.Error(err)
// }
// wg.Done()
// }(acnt)
// }
// wg.Wait()
// // Make sure action plan was properly rem/set
// aps = []*engine.ActionPlan{}
// if err := a1rpc.Call(utils.APIerSv1GetActionPlan, &v1.AttrGetActionPlan{ID: "PACKAGE_1"}, &aps); err != nil {
// t.Error(err)
// } else if len(aps[0].AccountIDs.Slice()) != 0 {
// t.Errorf("Received: %+v", aps[0])
// }
// aps = []*engine.ActionPlan{}
// if err := a1rpc.Call(utils.APIerSv1GetActionPlan, &v1.AttrGetActionPlan{ID: "PACKAGE_2"}, &aps); err != nil {
// t.Error(err)
// } else if len(aps[0].AccountIDs.Slice()) != len(acnts) {
// t.Errorf("Received: %+v", aps[0])
// }
// }
func testA1itStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testA1itStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

634
general_tests/accountactions_it_test.go
View File

@@ -21,337 +21,337 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"reflect"
"strconv"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "reflect"
// "strconv"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
accPrfCfgPath string
accPrfCfg *config.CGRConfig
accSRPC *rpc.Client
accPrfConfigDIR string //run tests for specific configuration
// var (
// accPrfCfgPath string
// accPrfCfg *config.CGRConfig
// accSRPC *rpc.Client
// accPrfConfigDIR string //run tests for specific configuration
sTestsAccPrf = []func(t *testing.T){
testAccActionsInitCfg,
testAccActionsInitDataDb,
testAccActionsResetStorDb,
testAccActionsStartEngine,
testAccActionsRPCConn,
testAccActionsSetActionProfile,
testAccActionsExecuteAction,
testAccActionsSetActionProfile,
testAccActionsExecuteAction2,
testAccActionsGetAccountAfterActions,
testAccActionsSetActionProfile2,
testAccActionsExecuteAction3,
testAccActionsGetAccountAfterRemActions,
testAccActionsKillEngine,
}
)
// sTestsAccPrf = []func(t *testing.T){
// testAccActionsInitCfg,
// testAccActionsInitDataDb,
// testAccActionsResetStorDb,
// testAccActionsStartEngine,
// testAccActionsRPCConn,
// testAccActionsSetActionProfile,
// testAccActionsExecuteAction,
// testAccActionsSetActionProfile,
// testAccActionsExecuteAction2,
// testAccActionsGetAccountAfterActions,
// testAccActionsSetActionProfile2,
// testAccActionsExecuteAction3,
// testAccActionsGetAccountAfterRemActions,
// testAccActionsKillEngine,
// }
// )
//Test start here
func TestAccActionsIT(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
accPrfConfigDIR = "tutinternal"
case utils.MetaMySQL:
accPrfConfigDIR = "tutmysql"
case utils.MetaMongo:
accPrfConfigDIR = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestsAccPrf {
t.Run(accPrfConfigDIR, stest)
}
}
// //Test start here
// func TestAccActionsIT(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// accPrfConfigDIR = "tutinternal"
// case utils.MetaMySQL:
// accPrfConfigDIR = "tutmysql"
// case utils.MetaMongo:
// accPrfConfigDIR = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sTestsAccPrf {
// t.Run(accPrfConfigDIR, stest)
// }
// }
func testAccActionsInitCfg(t *testing.T) {
var err error
accPrfCfgPath = path.Join(*dataDir, "conf", "samples", accPrfConfigDIR)
if accPrfCfg, err = config.NewCGRConfigFromPath(accPrfCfgPath); err != nil {
t.Error(err)
}
}
// func testAccActionsInitCfg(t *testing.T) {
// var err error
// accPrfCfgPath = path.Join(*dataDir, "conf", "samples", accPrfConfigDIR)
// if accPrfCfg, err = config.NewCGRConfigFromPath(accPrfCfgPath); err != nil {
// t.Error(err)
// }
// }
func testAccActionsInitDataDb(t *testing.T) {
if err := engine.InitDataDB(accPrfCfg); err != nil {
t.Fatal(err)
}
}
// func testAccActionsInitDataDb(t *testing.T) {
// if err := engine.InitDataDB(accPrfCfg); err != nil {
// t.Fatal(err)
// }
// }
// Wipe out the cdr database
func testAccActionsResetStorDb(t *testing.T) {
if err := engine.InitStorDB(accPrfCfg); err != nil {
t.Fatal(err)
}
}
// // Wipe out the cdr database
// func testAccActionsResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(accPrfCfg); err != nil {
// t.Fatal(err)
// }
// }
// Start CGR Engine
func testAccActionsStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(accPrfCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// // Start CGR Engine
// func testAccActionsStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(accPrfCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
// Connect rpc client to rater
func testAccActionsRPCConn(t *testing.T) {
var err error
accSRPC, err = newRPCClient(accPrfCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal(err)
}
}
// // Connect rpc client to rater
// func testAccActionsRPCConn(t *testing.T) {
// var err error
// accSRPC, err = newRPCClient(accPrfCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal(err)
// }
// }
func testAccActionsSetActionProfile(t *testing.T) {
actPrf := &engine.ActionProfileWithAPIOpts{
ActionProfile: &engine.ActionProfile{
Tenant: "cgrates.org",
ID: "CREATE_ACC",
FilterIDs: []string{"*string:~*req.Account:1001"},
Weight: 0,
Targets: map[string]utils.StringSet{utils.MetaAccounts: {"1001": {}}},
Schedule: utils.MetaASAP,
Actions: []*engine.APAction{
{
ID: "SET_NEW_BAL",
FilterIDs: []string{"*exists:*opts.BAL_NEW:"},
Type: utils.MetaSetBalance,
Diktats: []*engine.APDiktat{
{
Path: "*account.ThresholdIDs",
Value: utils.MetaNone,
},
{
Path: "*balance.MONETARY.Type",
Value: utils.MetaConcrete,
},
{
Path: "*balance.MONETARY.Units",
Value: "1048576",
},
{
Path: "*balance.MONETARY.Weights",
Value: "`;0`",
},
{
Path: "*balance.MONETARY.CostIncrements",
Value: "`*string:~*req.ToR:*data;1024;0;0.01`",
},
},
},
{
ID: "SET_ADD_BAL",
FilterIDs: []string{"*exists:*opts.BAL_ADD:"},
Type: utils.MetaAddBalance,
Diktats: []*engine.APDiktat{
{
Path: "*balance.VOICE.Type",
Value: utils.MetaAbstract,
},
{
Path: "*balance.VOICE.Units",
Value: strconv.FormatInt((3 * time.Hour).Nanoseconds(), 10),
},
{
Path: "*balance.VOICE.FilterIDs",
Value: "`*string:~*req.ToR:*voice`",
},
{
Path: "*balance.VOICE.Weights",
Value: "`;2`",
},
{
Path: "*balance.VOICE.CostIncrements",
Value: "`*string:~*req.ToR:*voice;1000000000;0;0.01`",
},
},
},
},
},
APIOpts: map[string]interface{}{},
}
var reply string
if err := accSRPC.Call(utils.APIerSv1SetActionProfile, actPrf, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
var result *engine.ActionProfile
if err := accSRPC.Call(utils.APIerSv1GetActionProfile, &utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{Tenant: actPrf.Tenant, ID: actPrf.ID}}, &result); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(actPrf.ActionProfile, result) {
t.Errorf("Expecting : %+v, received: %+v", actPrf.ActionProfile, result)
}
}
// func testAccActionsSetActionProfile(t *testing.T) {
// actPrf := &engine.ActionProfileWithAPIOpts{
// ActionProfile: &engine.ActionProfile{
// Tenant: "cgrates.org",
// ID: "CREATE_ACC",
// FilterIDs: []string{"*string:~*req.Account:1001"},
// Weight: 0,
// Targets: map[string]utils.StringSet{utils.MetaAccounts: {"1001": {}}},
// Schedule: utils.MetaASAP,
// Actions: []*engine.APAction{
// {
// ID: "SET_NEW_BAL",
// FilterIDs: []string{"*exists:*opts.BAL_NEW:"},
// Type: utils.MetaSetBalance,
// Diktats: []*engine.APDiktat{
// {
// Path: "*account.ThresholdIDs",
// Value: utils.MetaNone,
// },
// {
// Path: "*balance.MONETARY.Type",
// Value: utils.MetaConcrete,
// },
// {
// Path: "*balance.MONETARY.Units",
// Value: "1048576",
// },
// {
// Path: "*balance.MONETARY.Weights",
// Value: "`;0`",
// },
// {
// Path: "*balance.MONETARY.CostIncrements",
// Value: "`*string:~*req.ToR:*data;1024;0;0.01`",
// },
// },
// },
// {
// ID: "SET_ADD_BAL",
// FilterIDs: []string{"*exists:*opts.BAL_ADD:"},
// Type: utils.MetaAddBalance,
// Diktats: []*engine.APDiktat{
// {
// Path: "*balance.VOICE.Type",
// Value: utils.MetaAbstract,
// },
// {
// Path: "*balance.VOICE.Units",
// Value: strconv.FormatInt((3 * time.Hour).Nanoseconds(), 10),
// },
// {
// Path: "*balance.VOICE.FilterIDs",
// Value: "`*string:~*req.ToR:*voice`",
// },
// {
// Path: "*balance.VOICE.Weights",
// Value: "`;2`",
// },
// {
// Path: "*balance.VOICE.CostIncrements",
// Value: "`*string:~*req.ToR:*voice;1000000000;0;0.01`",
// },
// },
// },
// },
// },
// APIOpts: map[string]interface{}{},
// }
// var reply string
// if err := accSRPC.Call(utils.APIerSv1SetActionProfile, actPrf, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// var result *engine.ActionProfile
// if err := accSRPC.Call(utils.APIerSv1GetActionProfile, &utils.TenantIDWithAPIOpts{
// TenantID: &utils.TenantID{Tenant: actPrf.Tenant, ID: actPrf.ID}}, &result); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(actPrf.ActionProfile, result) {
// t.Errorf("Expecting : %+v, received: %+v", actPrf.ActionProfile, result)
// }
// }
func testAccActionsExecuteAction(t *testing.T) {
var reply string
if err := accSRPC.Call(utils.ActionSv1ExecuteActions, &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
"Account": 1001,
},
APIOpts: map[string]interface{}{
"BAL_NEW": true,
"BAL_ADD": true,
},
}, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
}
// func testAccActionsExecuteAction(t *testing.T) {
// var reply string
// if err := accSRPC.Call(utils.ActionSv1ExecuteActions, &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// "Account": 1001,
// },
// APIOpts: map[string]interface{}{
// "BAL_NEW": true,
// "BAL_ADD": true,
// },
// }, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// }
func testAccActionsExecuteAction2(t *testing.T) {
var reply string
if err := accSRPC.Call(utils.ActionSv1ExecuteActions, &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
"Account": 1001,
},
APIOpts: map[string]interface{}{
"BAL_NEW": true,
"BAL_ADD": true,
utils.OptsActionsActionProfileIDs: []string{"CREATE_ACC"},
},
}, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
}
// func testAccActionsExecuteAction2(t *testing.T) {
// var reply string
// if err := accSRPC.Call(utils.ActionSv1ExecuteActions, &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// "Account": 1001,
// },
// APIOpts: map[string]interface{}{
// "BAL_NEW": true,
// "BAL_ADD": true,
// utils.OptsActionsActionProfileIDs: []string{"CREATE_ACC"},
// },
// }, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// }
func testAccActionsGetAccountAfterActions(t *testing.T) {
accPrf := &utils.Account{
Tenant: "cgrates.org",
ID: "1001",
Balances: map[string]*utils.Balance{
"MONETARY": {
ID: "MONETARY",
Weights: utils.DynamicWeights{{}},
Type: utils.MetaConcrete,
Units: utils.NewDecimalFromFloat64(1048576),
CostIncrements: []*utils.CostIncrement{{
FilterIDs: []string{"*string:~*req.ToR:*data"},
Increment: utils.NewDecimalFromFloat64(1024),
FixedFee: utils.NewDecimalFromFloat64(0),
RecurrentFee: utils.NewDecimalFromFloat64(0.01),
}},
},
"VOICE": {
ID: "VOICE",
FilterIDs: []string{"*string:~*req.ToR:*voice"},
Weights: utils.DynamicWeights{{Weight: 2}},
Type: utils.MetaAbstract,
Units: utils.NewDecimalFromFloat64(2 * 10800000000000),
CostIncrements: []*utils.CostIncrement{{
FilterIDs: []string{"*string:~*req.ToR:*voice"},
Increment: utils.NewDecimalFromFloat64(1000000000),
FixedFee: utils.NewDecimalFromFloat64(0),
RecurrentFee: utils.NewDecimalFromFloat64(0.01),
}},
},
},
ThresholdIDs: []string{utils.MetaNone},
}
var result *utils.Account
if err := accSRPC.Call(utils.APIerSv1GetAccount, &utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "1001"}}, &result); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(accPrf, result) {
t.Errorf("Expecting : %s, received: %s", utils.ToJSON(accPrf), utils.ToJSON(result))
}
}
// func testAccActionsGetAccountAfterActions(t *testing.T) {
// accPrf := &utils.Account{
// Tenant: "cgrates.org",
// ID: "1001",
// Balances: map[string]*utils.Balance{
// "MONETARY": {
// ID: "MONETARY",
// Weights: utils.DynamicWeights{{}},
// Type: utils.MetaConcrete,
// Units: utils.NewDecimalFromFloat64(1048576),
// CostIncrements: []*utils.CostIncrement{{
// FilterIDs: []string{"*string:~*req.ToR:*data"},
// Increment: utils.NewDecimalFromFloat64(1024),
// FixedFee: utils.NewDecimalFromFloat64(0),
// RecurrentFee: utils.NewDecimalFromFloat64(0.01),
// }},
// },
// "VOICE": {
// ID: "VOICE",
// FilterIDs: []string{"*string:~*req.ToR:*voice"},
// Weights: utils.DynamicWeights{{Weight: 2}},
// Type: utils.MetaAbstract,
// Units: utils.NewDecimalFromFloat64(2 * 10800000000000),
// CostIncrements: []*utils.CostIncrement{{
// FilterIDs: []string{"*string:~*req.ToR:*voice"},
// Increment: utils.NewDecimalFromFloat64(1000000000),
// FixedFee: utils.NewDecimalFromFloat64(0),
// RecurrentFee: utils.NewDecimalFromFloat64(0.01),
// }},
// },
// },
// ThresholdIDs: []string{utils.MetaNone},
// }
// var result *utils.Account
// if err := accSRPC.Call(utils.APIerSv1GetAccount, &utils.TenantIDWithAPIOpts{
// TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "1001"}}, &result); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(accPrf, result) {
// t.Errorf("Expecting : %s, received: %s", utils.ToJSON(accPrf), utils.ToJSON(result))
// }
// }
func testAccActionsSetActionProfile2(t *testing.T) {
actPrf := &engine.ActionProfileWithAPIOpts{
ActionProfile: &engine.ActionProfile{
Tenant: "cgrates.org",
ID: "REM_ACC",
FilterIDs: []string{"*string:~*req.Account:1001"},
Weight: 0,
Targets: map[string]utils.StringSet{utils.MetaAccounts: {"1001": {}}},
Schedule: utils.MetaASAP,
Actions: []*engine.APAction{
{
ID: "REM_BAL",
Type: utils.MetaRemBalance,
Diktats: []*engine.APDiktat{
{
Path: "MONETARY",
},
{
Path: "VOICE",
},
},
},
},
},
APIOpts: map[string]interface{}{},
}
var reply string
if err := accSRPC.Call(utils.APIerSv1SetActionProfile, actPrf, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
var result *engine.ActionProfile
if err := accSRPC.Call(utils.APIerSv1GetActionProfile, &utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{Tenant: actPrf.Tenant, ID: actPrf.ID}}, &result); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(actPrf.ActionProfile, result) {
t.Errorf("Expecting : %+v, received: %+v", actPrf.ActionProfile, result)
}
}
// func testAccActionsSetActionProfile2(t *testing.T) {
// actPrf := &engine.ActionProfileWithAPIOpts{
// ActionProfile: &engine.ActionProfile{
// Tenant: "cgrates.org",
// ID: "REM_ACC",
// FilterIDs: []string{"*string:~*req.Account:1001"},
// Weight: 0,
// Targets: map[string]utils.StringSet{utils.MetaAccounts: {"1001": {}}},
// Schedule: utils.MetaASAP,
// Actions: []*engine.APAction{
// {
// ID: "REM_BAL",
// Type: utils.MetaRemBalance,
// Diktats: []*engine.APDiktat{
// {
// Path: "MONETARY",
// },
// {
// Path: "VOICE",
// },
// },
// },
// },
// },
// APIOpts: map[string]interface{}{},
// }
// var reply string
// if err := accSRPC.Call(utils.APIerSv1SetActionProfile, actPrf, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// var result *engine.ActionProfile
// if err := accSRPC.Call(utils.APIerSv1GetActionProfile, &utils.TenantIDWithAPIOpts{
// TenantID: &utils.TenantID{Tenant: actPrf.Tenant, ID: actPrf.ID}}, &result); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(actPrf.ActionProfile, result) {
// t.Errorf("Expecting : %+v, received: %+v", actPrf.ActionProfile, result)
// }
// }
func testAccActionsExecuteAction3(t *testing.T) {
var reply string
if err := accSRPC.Call(utils.ActionSv1ExecuteActions, &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
"Account": 1001,
},
APIOpts: map[string]interface{}{
utils.OptsActionsActionProfileIDs: []string{"REM_ACC"},
},
}, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
}
// func testAccActionsExecuteAction3(t *testing.T) {
// var reply string
// if err := accSRPC.Call(utils.ActionSv1ExecuteActions, &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// "Account": 1001,
// },
// APIOpts: map[string]interface{}{
// utils.OptsActionsActionProfileIDs: []string{"REM_ACC"},
// },
// }, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// }
func testAccActionsGetAccountAfterRemActions(t *testing.T) {
accPrf := &utils.Account{
Tenant: "cgrates.org",
ID: "1001",
Balances: map[string]*utils.Balance{},
ThresholdIDs: []string{utils.MetaNone},
}
var result *utils.Account
if err := accSRPC.Call(utils.APIerSv1GetAccount, &utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "1001"}}, &result); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(accPrf, result) {
t.Errorf("Expecting : %s, received: %s", utils.ToJSON(accPrf), utils.ToJSON(result))
}
}
// func testAccActionsGetAccountAfterRemActions(t *testing.T) {
// accPrf := &utils.Account{
// Tenant: "cgrates.org",
// ID: "1001",
// Balances: map[string]*utils.Balance{},
// ThresholdIDs: []string{utils.MetaNone},
// }
// var result *utils.Account
// if err := accSRPC.Call(utils.APIerSv1GetAccount, &utils.TenantIDWithAPIOpts{
// TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "1001"}}, &result); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(accPrf, result) {
// t.Errorf("Expecting : %s, received: %s", utils.ToJSON(accPrf), utils.ToJSON(result))
// }
// }
func testAccActionsKillEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testAccActionsKillEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

514
general_tests/accounts_it_test.go
View File

@@ -20,288 +20,288 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"net/rpc"
"path"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
accCfgPath string
accCfg *config.CGRConfig
accRpc *rpc.Client
accConfDIR string //run tests for specific configuration
account *engine.Account
accDelay int
// var (
// accCfgPath string
// accCfg *config.CGRConfig
// accRpc *rpc.Client
// accConfDIR string //run tests for specific configuration
// account *engine.Account
// accDelay int
sTestsAcc = []func(t *testing.T){
testV1AccLoadConfig,
testV1AccInitDataDb,
testAccResetStorDb,
testV1AccStartEngine,
testV1AccRpcConn,
testV1AccGetAccountBeforeSet,
testV1AccLoadTarrifPlans,
testV1AccGetAccountAfterLoad,
testV1AccRemAccount,
testV1AccGetAccountAfterDelete,
testV1AccSetAccount,
testV1AccGetAccountAfterSet,
testV1AccRemAccountSet,
testV1AccGetAccountSetAfterDelete,
//testV1AccRemAccountAfterDelete,
testV1AccMonthly,
testV1AccSendToThreshold,
testV1AccStopEngine,
}
)
// sTestsAcc = []func(t *testing.T){
// testV1AccLoadConfig,
// testV1AccInitDataDb,
// testAccResetStorDb,
// testV1AccStartEngine,
// testV1AccRpcConn,
// testV1AccGetAccountBeforeSet,
// testV1AccLoadTarrifPlans,
// testV1AccGetAccountAfterLoad,
// testV1AccRemAccount,
// testV1AccGetAccountAfterDelete,
// testV1AccSetAccount,
// testV1AccGetAccountAfterSet,
// testV1AccRemAccountSet,
// testV1AccGetAccountSetAfterDelete,
// //testV1AccRemAccountAfterDelete,
// testV1AccMonthly,
// testV1AccSendToThreshold,
// testV1AccStopEngine,
// }
// )
// Test start here
func TestAccIT(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
accConfDIR = "tutinternal"
case utils.MetaMySQL:
accConfDIR = "tutmysql"
case utils.MetaMongo:
accConfDIR = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
// // Test start here
// func TestAccIT(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// accConfDIR = "tutinternal"
// case utils.MetaMySQL:
// accConfDIR = "tutmysql"
// case utils.MetaMongo:
// accConfDIR = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
for _, stest := range sTestsAcc {
t.Run(accConfDIR, stest)
}
}
// for _, stest := range sTestsAcc {
// t.Run(accConfDIR, stest)
// }
// }
func testV1AccLoadConfig(t *testing.T) {
var err error
accCfgPath = path.Join(*dataDir, "conf", "samples", accConfDIR)
if accCfg, err = config.NewCGRConfigFromPath(accCfgPath); err != nil {
t.Error(err)
}
accDelay = 1000
}
// func testV1AccLoadConfig(t *testing.T) {
// var err error
// accCfgPath = path.Join(*dataDir, "conf", "samples", accConfDIR)
// if accCfg, err = config.NewCGRConfigFromPath(accCfgPath); err != nil {
// t.Error(err)
// }
// accDelay = 1000
// }
func testV1AccInitDataDb(t *testing.T) {
if err := engine.InitDataDB(accCfg); err != nil {
t.Fatal(err)
}
}
// func testV1AccInitDataDb(t *testing.T) {
// if err := engine.InitDataDB(accCfg); err != nil {
// t.Fatal(err)
// }
// }
func testAccResetStorDb(t *testing.T) {
if err := engine.InitStorDB(accCfg); err != nil {
t.Fatal(err)
}
}
// func testAccResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(accCfg); err != nil {
// t.Fatal(err)
// }
// }
func testV1AccStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(accCfgPath, accDelay); err != nil {
t.Fatal(err)
}
}
// func testV1AccStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(accCfgPath, accDelay); err != nil {
// t.Fatal(err)
// }
// }
func testV1AccRpcConn(t *testing.T) {
var err error
accRpc, err = newRPCClient(accCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal("Could not connect to rater: ", err.Error())
}
}
// func testV1AccRpcConn(t *testing.T) {
// var err error
// accRpc, err = newRPCClient(accCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal("Could not connect to rater: ", err.Error())
// }
// }
func testV1AccGetAccountBeforeSet(t *testing.T) {
var reply *engine.Account
if err := accRpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"}, &reply); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
// func testV1AccGetAccountBeforeSet(t *testing.T) {
// var reply *engine.Account
// if err := accRpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"}, &reply); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// }
func testV1AccLoadTarrifPlans(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")}
if err := accRpc.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
time.Sleep(200 * time.Millisecond)
}
// func testV1AccLoadTarrifPlans(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")}
// if err := accRpc.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// time.Sleep(200 * time.Millisecond)
// }
func testV1AccGetAccountAfterLoad(t *testing.T) {
var reply *engine.Account
if err := accRpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"},
&reply); err != nil {
t.Error(err)
}
}
// func testV1AccGetAccountAfterLoad(t *testing.T) {
// var reply *engine.Account
// if err := accRpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"},
// &reply); err != nil {
// t.Error(err)
// }
// }
func testV1AccRemAccount(t *testing.T) {
var reply string
if err := accRpc.Call(utils.APIerSv1RemoveAccount,
&utils.AttrRemoveAccount{Tenant: "cgrates.org", Account: "1001"},
&reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
}
// func testV1AccRemAccount(t *testing.T) {
// var reply string
// if err := accRpc.Call(utils.APIerSv1RemoveAccount,
// &utils.AttrRemoveAccount{Tenant: "cgrates.org", Account: "1001"},
// &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// }
func testV1AccGetAccountAfterDelete(t *testing.T) {
var reply *engine.Account
if err := accRpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"}, &reply); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
// func testV1AccGetAccountAfterDelete(t *testing.T) {
// var reply *engine.Account
// if err := accRpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"}, &reply); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// }
func testV1AccSetAccount(t *testing.T) {
var reply string
if err := accRpc.Call(utils.APIerSv2SetAccount,
&utils.AttrSetAccount{Tenant: "cgrates.org", Account: "testacc"}, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
}
// func testV1AccSetAccount(t *testing.T) {
// var reply string
// if err := accRpc.Call(utils.APIerSv2SetAccount,
// &utils.AttrSetAccount{Tenant: "cgrates.org", Account: "testacc"}, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// }
func testV1AccGetAccountAfterSet(t *testing.T) {
var reply *engine.Account
if err := accRpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "testacc"}, &reply); err != nil {
t.Error(err)
}
}
// func testV1AccGetAccountAfterSet(t *testing.T) {
// var reply *engine.Account
// if err := accRpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "testacc"}, &reply); err != nil {
// t.Error(err)
// }
// }
func testV1AccRemAccountSet(t *testing.T) {
var reply string
if err := accRpc.Call(utils.APIerSv1RemoveAccount,
&utils.AttrRemoveAccount{Tenant: "cgrates.org", Account: "testacc"},
&reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
}
// func testV1AccRemAccountSet(t *testing.T) {
// var reply string
// if err := accRpc.Call(utils.APIerSv1RemoveAccount,
// &utils.AttrRemoveAccount{Tenant: "cgrates.org", Account: "testacc"},
// &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// }
func testV1AccGetAccountSetAfterDelete(t *testing.T) {
var reply *engine.Account
if err := accRpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "testacc"},
&reply); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
// func testV1AccGetAccountSetAfterDelete(t *testing.T) {
// var reply *engine.Account
// if err := accRpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "testacc"},
// &reply); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// }
/*
Need to investigate for redis why didn't return not found
func testV1AccRemAccountAfterDelete(t *testing.T) {
var reply string
if err := accRpc.Call(utils.APIerSv1RemoveAccount,
&utils.AttrRemoveAccount{Tenant: "cgrates.org", Account: "testacc"},
&reply); err == nil || err.Error() != utils.NewErrServerError(utils.ErrNotFound).Error() {
t.Error(err)
}
}
*/
// /*
// Need to investigate for redis why didn't return not found
// func testV1AccRemAccountAfterDelete(t *testing.T) {
// var reply string
// if err := accRpc.Call(utils.APIerSv1RemoveAccount,
// &utils.AttrRemoveAccount{Tenant: "cgrates.org", Account: "testacc"},
// &reply); err == nil || err.Error() != utils.NewErrServerError(utils.ErrNotFound).Error() {
// t.Error(err)
// }
// }
// */
func testV1AccMonthly(t *testing.T) {
// add 10 seconds delay before and after
timeAfter := time.Now().Add(10*time.Second).AddDate(0, 1, 0)
timeBefore := time.Now().Add(-10*time.Second).AddDate(0, 1, 0)
var reply *engine.Account
if err := accRpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1002"},
&reply); err != nil {
t.Error(err)
} else if _, has := reply.BalanceMap[utils.MetaData]; !has {
t.Error("Unexpected balance returned: ", utils.ToJSON(reply.BalanceMap[utils.MetaData]))
} else if len(reply.BalanceMap[utils.MetaData]) != 1 {
t.Error("Unexpected number of balances returned: ", len(reply.BalanceMap[utils.MetaData]))
} else if reply.BalanceMap[utils.MetaData][0].ExpirationDate.After(timeAfter) &&
reply.BalanceMap[utils.MetaData][0].ExpirationDate.Before(timeBefore) {
t.Error("Unexpected expiration date returned: ", reply.BalanceMap[utils.MetaData][0].ExpirationDate)
}
// func testV1AccMonthly(t *testing.T) {
// // add 10 seconds delay before and after
// timeAfter := time.Now().Add(10*time.Second).AddDate(0, 1, 0)
// timeBefore := time.Now().Add(-10*time.Second).AddDate(0, 1, 0)
// var reply *engine.Account
// if err := accRpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1002"},
// &reply); err != nil {
// t.Error(err)
// } else if _, has := reply.BalanceMap[utils.MetaData]; !has {
// t.Error("Unexpected balance returned: ", utils.ToJSON(reply.BalanceMap[utils.MetaData]))
// } else if len(reply.BalanceMap[utils.MetaData]) != 1 {
// t.Error("Unexpected number of balances returned: ", len(reply.BalanceMap[utils.MetaData]))
// } else if reply.BalanceMap[utils.MetaData][0].ExpirationDate.After(timeAfter) &&
// reply.BalanceMap[utils.MetaData][0].ExpirationDate.Before(timeBefore) {
// t.Error("Unexpected expiration date returned: ", reply.BalanceMap[utils.MetaData][0].ExpirationDate)
// }
}
// }
//Add test to check if AccountS send event to ThresholdS
func testV1AccSendToThreshold(t *testing.T) {
var reply string
// //Add test to check if AccountS send event to ThresholdS
// func testV1AccSendToThreshold(t *testing.T) {
// var reply string
// Add a disable and log action
attrsAA := &utils.AttrSetActions{ActionsId: "DISABLE_LOG", Actions: []*utils.TPAction{
{Identifier: utils.MetaDisableAccount},
{Identifier: utils.MetaLog},
}}
if err := accRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
t.Error("Got error on APIerSv2.SetActions: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
}
// // Add a disable and log action
// attrsAA := &utils.AttrSetActions{ActionsId: "DISABLE_LOG", Actions: []*utils.TPAction{
// {Identifier: utils.MetaDisableAccount},
// {Identifier: utils.MetaLog},
// }}
// if err := accRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
// t.Error("Got error on APIerSv2.SetActions: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
// }
tPrfl := &engine.ThresholdProfileWithAPIOpts{
ThresholdProfile: &engine.ThresholdProfile{
Tenant: "cgrates.org",
ID: "THD_AccDisableAndLog",
FilterIDs: []string{"*string:~*opts.*eventType:AccountUpdate",
"*string:~*asm.ID:testAccThreshold"},
MaxHits: -1,
MinSleep: time.Second,
Weight: 20.0,
Async: true,
ActionProfileIDs: []string{"DISABLE_LOG"},
},
}
// tPrfl := &engine.ThresholdProfileWithAPIOpts{
// ThresholdProfile: &engine.ThresholdProfile{
// Tenant: "cgrates.org",
// ID: "THD_AccDisableAndLog",
// FilterIDs: []string{"*string:~*opts.*eventType:AccountUpdate",
// "*string:~*asm.ID:testAccThreshold"},
// MaxHits: -1,
// MinSleep: time.Second,
// Weight: 20.0,
// Async: true,
// ActionProfileIDs: []string{"DISABLE_LOG"},
// },
// }
if err := accRpc.Call(utils.APIerSv1SetThresholdProfile, tPrfl, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
// Add an account
attrs := &utils.AttrSetBalance{
Tenant: "cgrates.org",
Account: "testAccThreshold",
BalanceType: "*monetary",
Value: 1.5,
Balance: map[string]interface{}{
utils.ID: "testAccSetBalance",
},
}
if err := accRpc.Call(utils.APIerSv1SetBalance, attrs, &reply); err != nil {
t.Error("Got error on APIerSv1.SetBalance: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv1.SetBalance received: %s", reply)
}
// if err := accRpc.Call(utils.APIerSv1SetThresholdProfile, tPrfl, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// // Add an account
// attrs := &utils.AttrSetBalance{
// Tenant: "cgrates.org",
// Account: "testAccThreshold",
// BalanceType: "*monetary",
// Value: 1.5,
// Balance: map[string]interface{}{
// utils.ID: "testAccSetBalance",
// },
// }
// if err := accRpc.Call(utils.APIerSv1SetBalance, attrs, &reply); err != nil {
// t.Error("Got error on APIerSv1.SetBalance: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv1.SetBalance received: %s", reply)
// }
// give time to threshold to made the change
time.Sleep(10 * time.Millisecond)
//verify the account
var acnt *engine.Account
attrAcc := &utils.AttrGetAccount{
Tenant: "cgrates.org",
Account: "testAccThreshold",
}
if err := accRpc.Call(utils.APIerSv2GetAccount, attrAcc, &acnt); err != nil {
t.Error(err)
} else if acnt.Disabled != true {
t.Errorf("Expecting: true, received: %v", acnt.Disabled)
}
}
// // give time to threshold to made the change
// time.Sleep(10 * time.Millisecond)
// //verify the account
// var acnt *engine.Account
// attrAcc := &utils.AttrGetAccount{
// Tenant: "cgrates.org",
// Account: "testAccThreshold",
// }
// if err := accRpc.Call(utils.APIerSv2GetAccount, attrAcc, &acnt); err != nil {
// t.Error(err)
// } else if acnt.Disabled != true {
// t.Errorf("Expecting: true, received: %v", acnt.Disabled)
// }
// }
func testV1AccStopEngine(t *testing.T) {
if err := engine.KillEngine(accDelay); err != nil {
t.Error(err)
}
}
// func testV1AccStopEngine(t *testing.T) {
// if err := engine.KillEngine(accDelay); err != nil {
// t.Error(err)
// }
// }

850
general_tests/all_cfg_rld_it_test.go
View File

File diff suppressed because one or more lines are too long

2650
general_tests/all_sections_cfg_rld_it_test.go
View File

File diff suppressed because one or more lines are too long

458
general_tests/attributes_filters_index_it_test.go
View File

@@ -21,255 +21,255 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"reflect"
"testing"
// import (
// "net/rpc"
// "path"
// "reflect"
// "testing"
"github.com/cgrates/cgrates/apis"
"github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/apis"
// "github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/utils"
// )
var (
attrFltrCfgPath string
attrFltrCfg *config.CGRConfig
attrFltrRPC *rpc.Client
alsPrfFltrConfigDIR string
sTestsAlsFltrPrf = []func(t *testing.T){
testAttributeFltrSInitCfg,
testAttributeFltrSInitDataDb,
testAttributeFltrSResetStorDb,
testAttributeFltrSStartEngine,
testAttributeFltrSRPCConn,
// var (
// attrFltrCfgPath string
// attrFltrCfg *config.CGRConfig
// attrFltrRPC *rpc.Client
// alsPrfFltrConfigDIR string
// sTestsAlsFltrPrf = []func(t *testing.T){
// testAttributeFltrSInitCfg,
// testAttributeFltrSInitDataDb,
// testAttributeFltrSResetStorDb,
// testAttributeFltrSStartEngine,
// testAttributeFltrSRPCConn,
testAttributeSetFltr1,
testAttributeSetProfile,
testAttributeSetFltr2,
testAttributeRemoveFltr,
// testAttributeSetFltr1,
// testAttributeSetProfile,
// testAttributeSetFltr2,
// testAttributeRemoveFltr,
testAttributeFltrSStopEngine,
}
)
// testAttributeFltrSStopEngine,
// }
// )
func TestAttributeFilterSIT(t *testing.T) {
switch *dbType {
case utils.MetaMySQL:
alsPrfFltrConfigDIR = "attributesindexes_mysql"
case utils.MetaMongo:
alsPrfFltrConfigDIR = "attributesindexes_mongo"
case utils.MetaPostgres, utils.MetaInternal:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestsAlsFltrPrf {
t.Run(alsPrfFltrConfigDIR, stest)
}
}
// func TestAttributeFilterSIT(t *testing.T) {
// switch *dbType {
// case utils.MetaMySQL:
// alsPrfFltrConfigDIR = "attributesindexes_mysql"
// case utils.MetaMongo:
// alsPrfFltrConfigDIR = "attributesindexes_mongo"
// case utils.MetaPostgres, utils.MetaInternal:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sTestsAlsFltrPrf {
// t.Run(alsPrfFltrConfigDIR, stest)
// }
// }
func testAttributeFltrSInitCfg(t *testing.T) {
var err error
attrFltrCfgPath = path.Join(*dataDir, "conf", "samples", alsPrfFltrConfigDIR)
attrFltrCfg, err = config.NewCGRConfigFromPath(attrFltrCfgPath)
if err != nil {
t.Error(err)
}
}
// func testAttributeFltrSInitCfg(t *testing.T) {
// var err error
// attrFltrCfgPath = path.Join(*dataDir, "conf", "samples", alsPrfFltrConfigDIR)
// attrFltrCfg, err = config.NewCGRConfigFromPath(attrFltrCfgPath)
// if err != nil {
// t.Error(err)
// }
// }
func testAttributeFltrSInitDataDb(t *testing.T) {
if err := engine.InitDataDB(attrFltrCfg); err != nil {
t.Fatal(err)
}
}
// func testAttributeFltrSInitDataDb(t *testing.T) {
// if err := engine.InitDataDB(attrFltrCfg); err != nil {
// t.Fatal(err)
// }
// }
// Wipe out the cdr database
func testAttributeFltrSResetStorDb(t *testing.T) {
if err := engine.InitStorDB(attrFltrCfg); err != nil {
t.Fatal(err)
}
}
// // Wipe out the cdr database
// func testAttributeFltrSResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(attrFltrCfg); err != nil {
// t.Fatal(err)
// }
// }
// Start CGR Engine
func testAttributeFltrSStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(attrFltrCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// // Start CGR Engine
// func testAttributeFltrSStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(attrFltrCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
// Connect rpc client to rater
func testAttributeFltrSRPCConn(t *testing.T) {
var err error
attrFltrRPC, err = newRPCClient(attrFltrCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal(err)
}
}
// // Connect rpc client to rater
// func testAttributeFltrSRPCConn(t *testing.T) {
// var err error
// attrFltrRPC, err = newRPCClient(attrFltrCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal(err)
// }
// }
func testAttributeSetFltr1(t *testing.T) {
filter := &engine.FilterWithAPIOpts{
Filter: &engine.Filter{
Tenant: "cgrates.org",
ID: "FLTR_1",
Rules: []*engine.FilterRule{{
Element: "~*req.Subject",
Type: "*prefix",
Values: []string{"48"},
}},
},
}
var result string
if err := attrFltrRPC.Call(utils.AdminSv1SetFilter, filter, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
// func testAttributeSetFltr1(t *testing.T) {
// filter := &engine.FilterWithAPIOpts{
// Filter: &engine.Filter{
// Tenant: "cgrates.org",
// ID: "FLTR_1",
// Rules: []*engine.FilterRule{{
// Element: "~*req.Subject",
// Type: "*prefix",
// Values: []string{"48"},
// }},
// },
// }
// var result string
// if err := attrFltrRPC.Call(utils.AdminSv1SetFilter, filter, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
var indexes []string
if err := attrFltrRPC.Call(utils.AdminSv1GetFilterIndexes, &apis.AttrGetFilterIndexes{
ItemType: utils.MetaAttributes, Tenant: "cgrates.org", FilterType: utils.MetaPrefix},
&indexes); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
// var indexes []string
// if err := attrFltrRPC.Call(utils.AdminSv1GetFilterIndexes, &apis.AttrGetFilterIndexes{
// ItemType: utils.MetaAttributes, Tenant: "cgrates.org", FilterType: utils.MetaPrefix},
// &indexes); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// }
func testAttributeSetProfile(t *testing.T) {
var result string
alsPrf := &engine.APIAttributeProfileWithAPIOpts{
APIAttributeProfile: &engine.APIAttributeProfile{
Tenant: "cgrates.org",
ID: "ApierTest",
FilterIDs: []string{"FLTR_1"},
Attributes: []*engine.ExternalAttribute{{
Path: "*req.FL1",
Value: "Al1",
}},
Weight: 20,
},
}
if err := attrFltrRPC.Call(utils.AdminSv1SetAttributeProfile, alsPrf, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
// func testAttributeSetProfile(t *testing.T) {
// var result string
// alsPrf := &engine.APIAttributeProfileWithAPIOpts{
// APIAttributeProfile: &engine.APIAttributeProfile{
// Tenant: "cgrates.org",
// ID: "ApierTest",
// FilterIDs: []string{"FLTR_1"},
// Attributes: []*engine.ExternalAttribute{{
// Path: "*req.FL1",
// Value: "Al1",
// }},
// Weight: 20,
// },
// }
// if err := attrFltrRPC.Call(utils.AdminSv1SetAttributeProfile, alsPrf, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
ev := &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
"Subject": "44",
},
APIOpts: map[string]interface{}{},
}
var rplyEv engine.AttrSProcessEventReply
if err := attrFltrRPC.Call(utils.AttributeSv1ProcessEvent,
ev, &rplyEv); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("Expected %+v, received %+v", utils.ErrNotFound, err)
}
// ev := &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// "Subject": "44",
// },
// APIOpts: map[string]interface{}{},
// }
// var rplyEv engine.AttrSProcessEventReply
// if err := attrFltrRPC.Call(utils.AttributeSv1ProcessEvent,
// ev, &rplyEv); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Errorf("Expected %+v, received %+v", utils.ErrNotFound, err)
// }
var indexes []string
expIdx := []string{
"*prefix:*req.Subject:48:ApierTest",
}
if err := attrFltrRPC.Call(utils.AdminSv1GetFilterIndexes, &apis.AttrGetFilterIndexes{
ItemType: utils.MetaAttributes, Tenant: "cgrates.org", FilterType: utils.MetaPrefix},
&indexes); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(indexes, expIdx) {
t.Errorf("Expecting: %+v, received: %+v",
utils.ToJSON(expIdx), utils.ToJSON(indexes))
}
}
// var indexes []string
// expIdx := []string{
// "*prefix:*req.Subject:48:ApierTest",
// }
// if err := attrFltrRPC.Call(utils.AdminSv1GetFilterIndexes, &apis.AttrGetFilterIndexes{
// ItemType: utils.MetaAttributes, Tenant: "cgrates.org", FilterType: utils.MetaPrefix},
// &indexes); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(indexes, expIdx) {
// t.Errorf("Expecting: %+v, received: %+v",
// utils.ToJSON(expIdx), utils.ToJSON(indexes))
// }
// }
func testAttributeSetFltr2(t *testing.T) {
var result string
filter := &engine.FilterWithAPIOpts{
Filter: &engine.Filter{
Tenant: "cgrates.org",
ID: "FLTR_1",
Rules: []*engine.FilterRule{{
Element: "~*req.Subject",
Type: "*prefix",
Values: []string{"44"},
}},
},
}
if err := attrFltrRPC.Call(utils.AdminSv1SetFilter, filter, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
// func testAttributeSetFltr2(t *testing.T) {
// var result string
// filter := &engine.FilterWithAPIOpts{
// Filter: &engine.Filter{
// Tenant: "cgrates.org",
// ID: "FLTR_1",
// Rules: []*engine.FilterRule{{
// Element: "~*req.Subject",
// Type: "*prefix",
// Values: []string{"44"},
// }},
// },
// }
// if err := attrFltrRPC.Call(utils.AdminSv1SetFilter, filter, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
//same event for process
ev := &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
"Subject": "4444",
},
APIOpts: map[string]interface{}{},
}
exp := engine.AttrSProcessEventReply{
MatchedProfiles: []string{"cgrates.org:ApierTest"},
AlteredFields: []string{"*req.FL1"},
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
"Subject": "4444",
"FL1": "Al1",
},
APIOpts: map[string]interface{}{},
},
}
var rplyEv engine.AttrSProcessEventReply
if err := attrFltrRPC.Call(utils.AttributeSv1ProcessEvent,
ev, &rplyEv); err != nil {
t.Fatal(err)
} else if !reflect.DeepEqual(exp, rplyEv) {
t.Errorf("Expected %s, received %s", utils.ToJSON(exp), utils.ToJSON(rplyEv))
}
// //same event for process
// ev := &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// "Subject": "4444",
// },
// APIOpts: map[string]interface{}{},
// }
// exp := engine.AttrSProcessEventReply{
// MatchedProfiles: []string{"cgrates.org:ApierTest"},
// AlteredFields: []string{"*req.FL1"},
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// "Subject": "4444",
// "FL1": "Al1",
// },
// APIOpts: map[string]interface{}{},
// },
// }
// var rplyEv engine.AttrSProcessEventReply
// if err := attrFltrRPC.Call(utils.AttributeSv1ProcessEvent,
// ev, &rplyEv); err != nil {
// t.Fatal(err)
// } else if !reflect.DeepEqual(exp, rplyEv) {
// t.Errorf("Expected %s, received %s", utils.ToJSON(exp), utils.ToJSON(rplyEv))
// }
var indexes []string
expIdx := []string{
"*prefix:*req.Subject:44:ApierTest",
}
if err := attrFltrRPC.Call(utils.AdminSv1GetFilterIndexes, &apis.AttrGetFilterIndexes{
ItemType: utils.MetaAttributes, Tenant: "cgrates.org", FilterType: utils.MetaPrefix},
&indexes); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(indexes, expIdx) {
t.Errorf("Expecting: %+v, received: %+v",
utils.ToJSON(expIdx), utils.ToJSON(indexes))
}
}
// var indexes []string
// expIdx := []string{
// "*prefix:*req.Subject:44:ApierTest",
// }
// if err := attrFltrRPC.Call(utils.AdminSv1GetFilterIndexes, &apis.AttrGetFilterIndexes{
// ItemType: utils.MetaAttributes, Tenant: "cgrates.org", FilterType: utils.MetaPrefix},
// &indexes); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(indexes, expIdx) {
// t.Errorf("Expecting: %+v, received: %+v",
// utils.ToJSON(expIdx), utils.ToJSON(indexes))
// }
// }
func testAttributeRemoveFltr(t *testing.T) {
var result string
if err := attrFltrRPC.Call(utils.AdminSv1RemoveAttributeProfile, &utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "ApierTest"}}, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
// func testAttributeRemoveFltr(t *testing.T) {
// var result string
// if err := attrFltrRPC.Call(utils.AdminSv1RemoveAttributeProfile, &utils.TenantIDWithAPIOpts{
// TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "ApierTest"}}, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
if err := attrFltrRPC.Call(utils.AdminSv1RemoveFilter, &utils.TenantIDWithAPIOpts{
TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "FLTR_1"}}, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
// if err := attrFltrRPC.Call(utils.AdminSv1RemoveFilter, &utils.TenantIDWithAPIOpts{
// TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "FLTR_1"}}, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
var indexes []string
if err := attrFltrRPC.Call(utils.AdminSv1GetFilterIndexes, &apis.AttrGetFilterIndexes{
ItemType: utils.MetaAttributes, Tenant: "cgrates.org", FilterType: utils.MetaPrefix},
&indexes); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
// var indexes []string
// if err := attrFltrRPC.Call(utils.AdminSv1GetFilterIndexes, &apis.AttrGetFilterIndexes{
// ItemType: utils.MetaAttributes, Tenant: "cgrates.org", FilterType: utils.MetaPrefix},
// &indexes); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// }
func testAttributeFltrSStopEngine(t *testing.T) {
if err := engine.KillEngine(*waitRater); err != nil {
t.Error(err)
}
}
// func testAttributeFltrSStopEngine(t *testing.T) {
// if err := engine.KillEngine(*waitRater); err != nil {
// t.Error(err)
// }
// }

1864
general_tests/attributes_it_test.go
View File

File diff suppressed because it is too large Load Diff

356
general_tests/broadcast_client_it_test.go
View File

@@ -20,198 +20,198 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"net/rpc"
"path"
"reflect"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "reflect"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
brodcastCfgPath string
brodcastInternalCfgPath string
brodcastInternalCfgDIR string
brodcastCfg *config.CGRConfig
brodcastInternalCfg *config.CGRConfig
brodcastRPC *rpc.Client
brodcastInternalRPC *rpc.Client
// var (
// brodcastCfgPath string
// brodcastInternalCfgPath string
// brodcastInternalCfgDIR string
// brodcastCfg *config.CGRConfig
// brodcastInternalCfg *config.CGRConfig
// brodcastRPC *rpc.Client
// brodcastInternalRPC *rpc.Client
sTestBrodcastIt = []func(t *testing.T){
testbrodcastItLoadConfig,
testbrodcastItResetDataDB,
testbrodcastItResetStorDb,
testbrodcastItStartEngine,
testbrodcastItRPCConn,
testbrodcastItLoadFromFolder,
// sTestBrodcastIt = []func(t *testing.T){
// testbrodcastItLoadConfig,
// testbrodcastItResetDataDB,
// testbrodcastItResetStorDb,
// testbrodcastItStartEngine,
// testbrodcastItRPCConn,
// testbrodcastItLoadFromFolder,
testbrodcastItProccessEvent,
testbrodcastItGetCDRs,
// testbrodcastItProccessEvent,
// testbrodcastItGetCDRs,
testbrodcastItStopCgrEngine,
}
)
// testbrodcastItStopCgrEngine,
// }
// )
func TestBrodcastRPC(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
brodcastInternalCfgDIR = "tutinternal"
case utils.MetaMySQL:
brodcastInternalCfgDIR = "tutmysql"
case utils.MetaMongo:
brodcastInternalCfgDIR = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
// func TestBrodcastRPC(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// brodcastInternalCfgDIR = "tutinternal"
// case utils.MetaMySQL:
// brodcastInternalCfgDIR = "tutmysql"
// case utils.MetaMongo:
// brodcastInternalCfgDIR = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
for _, stest := range sTestBrodcastIt {
t.Run(brodcastInternalCfgDIR, stest)
}
}
// for _, stest := range sTestBrodcastIt {
// t.Run(brodcastInternalCfgDIR, stest)
// }
// }
// test for 0 balance with session terminate with 1s usage
func testbrodcastItLoadConfig(t *testing.T) {
var err error
brodcastCfgPath = path.Join(*dataDir, "conf", "samples", "internal_broadcast_replication")
if brodcastCfg, err = config.NewCGRConfigFromPath(brodcastCfgPath); err != nil {
t.Error(err)
}
brodcastInternalCfgPath = path.Join(*dataDir, "conf", "samples", brodcastInternalCfgDIR)
if brodcastInternalCfg, err = config.NewCGRConfigFromPath(brodcastInternalCfgPath); err != nil {
t.Error(err)
}
}
// // test for 0 balance with session terminate with 1s usage
// func testbrodcastItLoadConfig(t *testing.T) {
// var err error
// brodcastCfgPath = path.Join(*dataDir, "conf", "samples", "internal_broadcast_replication")
// if brodcastCfg, err = config.NewCGRConfigFromPath(brodcastCfgPath); err != nil {
// t.Error(err)
// }
// brodcastInternalCfgPath = path.Join(*dataDir, "conf", "samples", brodcastInternalCfgDIR)
// if brodcastInternalCfg, err = config.NewCGRConfigFromPath(brodcastInternalCfgPath); err != nil {
// t.Error(err)
// }
// }
func testbrodcastItResetDataDB(t *testing.T) {
if err := engine.InitDataDB(brodcastInternalCfg); err != nil {
t.Fatal(err)
}
}
// func testbrodcastItResetDataDB(t *testing.T) {
// if err := engine.InitDataDB(brodcastInternalCfg); err != nil {
// t.Fatal(err)
// }
// }
func testbrodcastItResetStorDb(t *testing.T) {
if err := engine.InitStorDB(brodcastInternalCfg); err != nil {
t.Fatal(err)
}
}
// func testbrodcastItResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(brodcastInternalCfg); err != nil {
// t.Fatal(err)
// }
// }
func testbrodcastItStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(brodcastCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
if _, err := engine.StartEngine(brodcastInternalCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testbrodcastItStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(brodcastCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// if _, err := engine.StartEngine(brodcastInternalCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testbrodcastItRPCConn(t *testing.T) {
var err error
brodcastRPC, err = newRPCClient(brodcastCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
brodcastInternalRPC, err = newRPCClient(brodcastInternalCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testbrodcastItRPCConn(t *testing.T) {
// var err error
// brodcastRPC, err = newRPCClient(brodcastCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// brodcastInternalRPC, err = newRPCClient(brodcastInternalCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testbrodcastItLoadFromFolder(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")}
if err := brodcastRPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
}
if err := brodcastInternalRPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
}
time.Sleep(200 * time.Millisecond)
}
// func testbrodcastItLoadFromFolder(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")}
// if err := brodcastRPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// }
// if err := brodcastInternalRPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// }
// time.Sleep(200 * time.Millisecond)
// }
func testbrodcastItProccessEvent(t *testing.T) {
args := utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSSv1ItProcessCDR",
Event: map[string]interface{}{
utils.Tenant: "cgrates.org",
utils.Category: utils.Call,
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestSSv1It1Brodcast",
utils.RequestType: utils.MetaPostpaid,
utils.AccountField: "1001",
utils.Destination: "1002",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 10 * time.Minute,
},
}
// func testbrodcastItProccessEvent(t *testing.T) {
// args := utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSSv1ItProcessCDR",
// Event: map[string]interface{}{
// utils.Tenant: "cgrates.org",
// utils.Category: utils.Call,
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestSSv1It1Brodcast",
// utils.RequestType: utils.MetaPostpaid,
// utils.AccountField: "1001",
// utils.Destination: "1002",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 10 * time.Minute,
// },
// }
var rply string
if err := brodcastRPC.Call(utils.SessionSv1ProcessCDR, args, &rply); err != nil {
t.Fatal(err)
}
if rply != utils.OK {
t.Errorf("Unexpected reply: %s", rply)
}
time.Sleep(50 * time.Millisecond)
}
func testbrodcastItGetCDRs(t *testing.T) {
eCDR := &engine.CDR{
CGRID: "ad6cb338dea6eaf2e81507623fbd6b00f60c374f",
RunID: "*default",
OrderID: 0,
OriginHost: "",
Source: "*sessions",
OriginID: "TestSSv1It1Brodcast",
ToR: "*voice",
RequestType: "*postpaid",
Tenant: "cgrates.org",
Category: "call",
Account: "1001",
Subject: "1001",
Destination: "1002",
SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
Usage: 600000000000,
ExtraFields: make(map[string]string),
ExtraInfo: "NOT_CONNECTED: RALs",
Partial: false,
PreRated: false,
CostSource: "",
Cost: -1,
}
var cdrs []*engine.CDR
args := utils.RPCCDRsFilterWithAPIOpts{RPCCDRsFilter: &utils.RPCCDRsFilter{RunIDs: []string{utils.MetaDefault}}}
if err := brodcastRPC.Call(utils.CDRsV1GetCDRs, &args, &cdrs); err != nil {
t.Fatal("Unexpected error: ", err.Error())
} else if len(cdrs) != 1 {
t.Fatal("Unexpected number of CDRs returned: ", len(cdrs))
}
cdrs[0].OrderID = 0 // reset the OrderID
if !reflect.DeepEqual(eCDR, cdrs[0]) {
t.Errorf("Expected: %s ,received: %s", utils.ToJSON(eCDR), utils.ToJSON(cdrs[0]))
}
// var rply string
// if err := brodcastRPC.Call(utils.SessionSv1ProcessCDR, args, &rply); err != nil {
// t.Fatal(err)
// }
// if rply != utils.OK {
// t.Errorf("Unexpected reply: %s", rply)
// }
// time.Sleep(50 * time.Millisecond)
// }
// func testbrodcastItGetCDRs(t *testing.T) {
// eCDR := &engine.CDR{
// CGRID: "ad6cb338dea6eaf2e81507623fbd6b00f60c374f",
// RunID: "*default",
// OrderID: 0,
// OriginHost: "",
// Source: "*sessions",
// OriginID: "TestSSv1It1Brodcast",
// ToR: "*voice",
// RequestType: "*postpaid",
// Tenant: "cgrates.org",
// Category: "call",
// Account: "1001",
// Subject: "1001",
// Destination: "1002",
// SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// Usage: 600000000000,
// ExtraFields: make(map[string]string),
// ExtraInfo: "NOT_CONNECTED: RALs",
// Partial: false,
// PreRated: false,
// CostSource: "",
// Cost: -1,
// }
// var cdrs []*engine.CDR
// args := utils.RPCCDRsFilterWithAPIOpts{RPCCDRsFilter: &utils.RPCCDRsFilter{RunIDs: []string{utils.MetaDefault}}}
// if err := brodcastRPC.Call(utils.CDRsV1GetCDRs, &args, &cdrs); err != nil {
// t.Fatal("Unexpected error: ", err.Error())
// } else if len(cdrs) != 1 {
// t.Fatal("Unexpected number of CDRs returned: ", len(cdrs))
// }
// cdrs[0].OrderID = 0 // reset the OrderID
// if !reflect.DeepEqual(eCDR, cdrs[0]) {
// t.Errorf("Expected: %s ,received: %s", utils.ToJSON(eCDR), utils.ToJSON(cdrs[0]))
// }
if err := brodcastInternalRPC.Call(utils.CDRsV1GetCDRs, &args, &cdrs); err != nil {
t.Fatal("Unexpected error: ", err.Error())
} else if len(cdrs) != 1 {
t.Error("Unexpected number of CDRs returned: ", len(cdrs))
}
cdrs[0].OrderID = 0 // reset the OrderID
cdrs[0].SetupTime = cdrs[0].SetupTime.UTC() // uniform time
cdrs[0].AnswerTime = cdrs[0].AnswerTime.UTC() // uniform time
if !reflect.DeepEqual(eCDR, cdrs[0]) {
t.Errorf("Expected: %s ,received: %s", utils.ToJSON(eCDR), utils.ToJSON(cdrs[0]))
}
}
// if err := brodcastInternalRPC.Call(utils.CDRsV1GetCDRs, &args, &cdrs); err != nil {
// t.Fatal("Unexpected error: ", err.Error())
// } else if len(cdrs) != 1 {
// t.Error("Unexpected number of CDRs returned: ", len(cdrs))
// }
// cdrs[0].OrderID = 0 // reset the OrderID
// cdrs[0].SetupTime = cdrs[0].SetupTime.UTC() // uniform time
// cdrs[0].AnswerTime = cdrs[0].AnswerTime.UTC() // uniform time
// if !reflect.DeepEqual(eCDR, cdrs[0]) {
// t.Errorf("Expected: %s ,received: %s", utils.ToJSON(eCDR), utils.ToJSON(cdrs[0]))
// }
// }
func testbrodcastItStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testbrodcastItStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

1116
general_tests/cacherpl_it_test.go
View File

File diff suppressed because it is too large Load Diff

204
general_tests/cdrs_internal_it_test.go
View File

@@ -21,115 +21,115 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"path"
"testing"
"time"
// import (
// "path"
// "testing"
// "time"
"github.com/cgrates/birpc"
"github.com/cgrates/birpc/context"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/birpc"
// "github.com/cgrates/birpc/context"
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
cdrsIntCfgPath string
cdrsIntCfgDIR string
cdrsIntCfg *config.CGRConfig
cdrsIntRPC *birpc.Client
// var (
// cdrsIntCfgPath string
// cdrsIntCfgDIR string
// cdrsIntCfg *config.CGRConfig
// cdrsIntRPC *birpc.Client
sTestsCdrsInt = []func(t *testing.T){
testCdrsIntInitCfg,
testCdrsIntStartEngine,
testCdrsIntRpcConn,
testCdrsIntTestTTL,
testCdrsIntStopEngine,
}
)
// sTestsCdrsInt = []func(t *testing.T){
// testCdrsIntInitCfg,
// testCdrsIntStartEngine,
// testCdrsIntRpcConn,
// testCdrsIntTestTTL,
// testCdrsIntStopEngine,
// }
// )
// This test is valid only for internal
// to test the ttl for cdrs
func TestCdrsIntIT(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
cdrsIntCfgDIR = "internal_ttl_internal"
case utils.MetaMySQL:
t.SkipNow()
case utils.MetaMongo:
t.SkipNow()
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestsCdrsInt {
t.Run(cdrsIntCfgDIR, stest)
}
}
// // This test is valid only for internal
// // to test the ttl for cdrs
// func TestCdrsIntIT(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// cdrsIntCfgDIR = "internal_ttl_internal"
// case utils.MetaMySQL:
// t.SkipNow()
// case utils.MetaMongo:
// t.SkipNow()
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sTestsCdrsInt {
// t.Run(cdrsIntCfgDIR, stest)
// }
// }
func testCdrsIntInitCfg(t *testing.T) {
var err error
cdrsIntCfgPath = path.Join(*dataDir, "conf", "samples", cdrsIntCfgDIR)
cdrsIntCfg, err = config.NewCGRConfigFromPath(context.Background(), cdrsIntCfgPath)
if err != nil {
t.Error(err)
}
}
// func testCdrsIntInitCfg(t *testing.T) {
// var err error
// cdrsIntCfgPath = path.Join(*dataDir, "conf", "samples", cdrsIntCfgDIR)
// cdrsIntCfg, err = config.NewCGRConfigFromPath(context.Background(), cdrsIntCfgPath)
// if err != nil {
// t.Error(err)
// }
// }
func testCdrsIntStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(cdrsIntCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testCdrsIntStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(cdrsIntCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testCdrsIntRpcConn(t *testing.T) {
var err error
cdrsIntRPC, err = newRPCClient(cdrsIntCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testCdrsIntRpcConn(t *testing.T) {
// var err error
// cdrsIntRPC, err = newRPCClient(cdrsIntCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testCdrsIntTestTTL(t *testing.T) {
args := &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
utils.OriginID: "testCdrsIntTestTTL",
utils.OriginHost: "192.168.1.1",
utils.Source: "testCdrsIntTestTTL",
utils.RequestType: utils.MetaNone,
utils.Category: "call",
utils.AccountField: "testCdrsIntTestTTL",
utils.Subject: "ANY2CNT2",
utils.Destination: "+4986517174963",
utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
utils.Usage: time.Minute,
},
APIOpts: map[string]interface{}{utils.OptsCDRsStore: true},
}
// func testCdrsIntTestTTL(t *testing.T) {
// args := &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// utils.OriginID: "testCdrsIntTestTTL",
// utils.OriginHost: "192.168.1.1",
// utils.Source: "testCdrsIntTestTTL",
// utils.RequestType: utils.MetaNone,
// utils.Category: "call",
// utils.AccountField: "testCdrsIntTestTTL",
// utils.Subject: "ANY2CNT2",
// utils.Destination: "+4986517174963",
// utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
// utils.Usage: time.Minute,
// },
// APIOpts: map[string]interface{}{utils.OptsCDRsStore: true},
// }
var reply string
if err := cdrsIntRPC.Call(context.Background(), utils.CDRsV1ProcessEvent, args, &reply); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if reply != utils.OK {
t.Error("Unexpected reply received: ", reply)
}
var cdrs []*engine.ExternalCDR
if err := cdrsIntRPC.Call(utils.APIerSv2GetCDRs, &utils.RPCCDRsFilter{}, &cdrs); err != nil {
t.Fatal("Unexpected error: ", err.Error())
} else if len(cdrs) != 1 {
t.Errorf("Expected 1 result received %v ", len(cdrs))
}
time.Sleep(time.Second + 50*time.Millisecond)
if err := cdrsIntRPC.Call(utils.APIerSv2GetCDRs, &utils.RPCCDRsFilter{}, &cdrs); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Fatal("Unexpected error: ", err)
}
}
// var reply string
// if err := cdrsIntRPC.Call(context.Background(), utils.CDRsV1ProcessEvent, args, &reply); err != nil {
// t.Error("Unexpected error: ", err.Error())
// } else if reply != utils.OK {
// t.Error("Unexpected reply received: ", reply)
// }
// var cdrs []*engine.ExternalCDR
// if err := cdrsIntRPC.Call(utils.APIerSv2GetCDRs, &utils.RPCCDRsFilter{}, &cdrs); err != nil {
// t.Fatal("Unexpected error: ", err.Error())
// } else if len(cdrs) != 1 {
// t.Errorf("Expected 1 result received %v ", len(cdrs))
// }
// time.Sleep(time.Second + 50*time.Millisecond)
// if err := cdrsIntRPC.Call(utils.APIerSv2GetCDRs, &utils.RPCCDRsFilter{}, &cdrs); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Fatal("Unexpected error: ", err)
// }
// }
func testCdrsIntStopEngine(t *testing.T) {
if err := engine.KillEngine(*waitRater); err != nil {
t.Error(err)
}
}
// func testCdrsIntStopEngine(t *testing.T) {
// if err := engine.KillEngine(*waitRater); err != nil {
// t.Error(err)
// }
// }

1348
general_tests/cdrs_it_test.go
View File

File diff suppressed because it is too large Load Diff

928
general_tests/cdrs_onlexp_it_test.go
View File

@@ -21,503 +21,503 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"encoding/json"
"fmt"
"net/http"
"net/url"
"os"
"os/exec"
"path"
"reflect"
"testing"
"time"
// import (
// "encoding/json"
// "fmt"
// "net/http"
// "net/url"
// "os"
// "os/exec"
// "path"
// "reflect"
// "testing"
// "time"
"github.com/cgrates/birpc/context"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/ees"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/rpcclient"
kafka "github.com/segmentio/kafka-go"
"github.com/streadway/amqp"
)
// "github.com/cgrates/birpc/context"
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/ees"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// "github.com/cgrates/rpcclient"
// kafka "github.com/segmentio/kafka-go"
// "github.com/streadway/amqp"
// )
var (
cdrsMasterCfgPath, cdrsSlaveCfgPath string
cdrsMasterCfgDIR, cdrsSlaveCfgDIR string
cdrsMasterCfg, cdrsSlaveCfg *config.CGRConfig
cdrsMasterRpc *rpcclient.RPCClient
httpCGRID = utils.UUIDSha1Prefix()
amqpCGRID = utils.UUIDSha1Prefix()
failoverContent = [][]byte{[]byte(fmt.Sprintf(`{"CGRID":"%s"}`, httpCGRID)), []byte(fmt.Sprintf(`{"CGRID":"%s"}`, amqpCGRID))}
// var (
// cdrsMasterCfgPath, cdrsSlaveCfgPath string
// cdrsMasterCfgDIR, cdrsSlaveCfgDIR string
// cdrsMasterCfg, cdrsSlaveCfg *config.CGRConfig
// cdrsMasterRpc *rpcclient.RPCClient
// httpCGRID = utils.UUIDSha1Prefix()
// amqpCGRID = utils.UUIDSha1Prefix()
// failoverContent = [][]byte{[]byte(fmt.Sprintf(`{"CGRID":"%s"}`, httpCGRID)), []byte(fmt.Sprintf(`{"CGRID":"%s"}`, amqpCGRID))}
sTestsCDRsOnExp = []func(t *testing.T){
testCDRsOnExpInitConfig,
testCDRsOnExpInitCdrDb,
testCDRsOnExpStartMasterEngine,
testCDRsOnExpStartSlaveEngine,
testCDRsOnExpAMQPQueuesCreation,
testCDRsOnExpInitMasterRPC,
testCDRsOnExpLoadDefaultCharger,
testCDRsOnExpDisableOnlineExport,
testCDRsOnExpHttpCdrReplication,
testCDRsOnExpAMQPReplication,
testCDRsOnExpFileFailover,
testCDRsOnExpKafkaPosterFileFailover,
testCDRsOnExpStopEngine,
}
)
// sTestsCDRsOnExp = []func(t *testing.T){
// testCDRsOnExpInitConfig,
// testCDRsOnExpInitCdrDb,
// testCDRsOnExpStartMasterEngine,
// testCDRsOnExpStartSlaveEngine,
// testCDRsOnExpAMQPQueuesCreation,
// testCDRsOnExpInitMasterRPC,
// testCDRsOnExpLoadDefaultCharger,
// testCDRsOnExpDisableOnlineExport,
// testCDRsOnExpHttpCdrReplication,
// testCDRsOnExpAMQPReplication,
// testCDRsOnExpFileFailover,
// testCDRsOnExpKafkaPosterFileFailover,
// testCDRsOnExpStopEngine,
// }
// )
func TestCDRsOnExp(t *testing.T) {
switch *dbType {
case utils.MetaInternal, utils.MetaPostgres:
t.SkipNow()
case utils.MetaMySQL:
cdrsMasterCfgDIR = "cdrsonexpmaster_mysql"
cdrsSlaveCfgDIR = "cdrsonexpslave_mysql"
case utils.MetaMongo:
cdrsMasterCfgDIR = "cdrsonexpmaster_mongo"
cdrsSlaveCfgDIR = "cdrsonexpslave_mongo"
default:
t.Fatal("Unknown Database type")
}
// func TestCDRsOnExp(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal, utils.MetaPostgres:
// t.SkipNow()
// case utils.MetaMySQL:
// cdrsMasterCfgDIR = "cdrsonexpmaster_mysql"
// cdrsSlaveCfgDIR = "cdrsonexpslave_mysql"
// case utils.MetaMongo:
// cdrsMasterCfgDIR = "cdrsonexpmaster_mongo"
// cdrsSlaveCfgDIR = "cdrsonexpslave_mongo"
// default:
// t.Fatal("Unknown Database type")
// }
for _, stest := range sTestsCDRsOnExp {
t.Run(*dbType, stest)
}
}
// for _, stest := range sTestsCDRsOnExp {
// t.Run(*dbType, stest)
// }
// }
func testCDRsOnExpInitConfig(t *testing.T) {
var err error
cdrsMasterCfgPath = path.Join(*dataDir, "conf", "samples", cdrsMasterCfgDIR)
if cdrsMasterCfg, err = config.NewCGRConfigFromPath(context.Background(), cdrsMasterCfgPath); err != nil {
t.Fatal("Got config error: ", err.Error())
}
cdrsSlaveCfgPath = path.Join(*dataDir, "conf", "samples", cdrsSlaveCfgDIR)
if cdrsSlaveCfg, err = config.NewCGRConfigFromPath(context.Background(), cdrsSlaveCfgPath); err != nil {
t.Fatal("Got config error: ", err.Error())
}
}
// func testCDRsOnExpInitConfig(t *testing.T) {
// var err error
// cdrsMasterCfgPath = path.Join(*dataDir, "conf", "samples", cdrsMasterCfgDIR)
// if cdrsMasterCfg, err = config.NewCGRConfigFromPath(context.Background(), cdrsMasterCfgPath); err != nil {
// t.Fatal("Got config error: ", err.Error())
// }
// cdrsSlaveCfgPath = path.Join(*dataDir, "conf", "samples", cdrsSlaveCfgDIR)
// if cdrsSlaveCfg, err = config.NewCGRConfigFromPath(context.Background(), cdrsSlaveCfgPath); err != nil {
// t.Fatal("Got config error: ", err.Error())
// }
// }
// InitDb so we can rely on count
func testCDRsOnExpInitCdrDb(t *testing.T) {
if err := engine.InitDataDB(cdrsMasterCfg); err != nil {
t.Fatal(err)
}
if err := engine.InitDataDB(cdrsSlaveCfg); err != nil {
t.Fatal(err)
}
if err := engine.InitStorDB(cdrsMasterCfg); err != nil {
t.Fatal(err)
}
if err := engine.InitStorDB(cdrsSlaveCfg); err != nil {
t.Fatal(err)
}
if err := os.RemoveAll(cdrsMasterCfg.GeneralCfg().FailedPostsDir); err != nil {
t.Fatal("Error removing folder: ", cdrsMasterCfg.GeneralCfg().FailedPostsDir, err)
}
// // InitDb so we can rely on count
// func testCDRsOnExpInitCdrDb(t *testing.T) {
// if err := engine.InitDataDB(cdrsMasterCfg); err != nil {
// t.Fatal(err)
// }
// if err := engine.InitDataDB(cdrsSlaveCfg); err != nil {
// t.Fatal(err)
// }
// if err := engine.InitStorDB(cdrsMasterCfg); err != nil {
// t.Fatal(err)
// }
// if err := engine.InitStorDB(cdrsSlaveCfg); err != nil {
// t.Fatal(err)
// }
// if err := os.RemoveAll(cdrsMasterCfg.GeneralCfg().FailedPostsDir); err != nil {
// t.Fatal("Error removing folder: ", cdrsMasterCfg.GeneralCfg().FailedPostsDir, err)
// }
if err := os.MkdirAll(cdrsMasterCfg.GeneralCfg().FailedPostsDir, 0700); err != nil {
t.Error(err)
}
// if err := os.MkdirAll(cdrsMasterCfg.GeneralCfg().FailedPostsDir, 0700); err != nil {
// t.Error(err)
// }
}
// }
func testCDRsOnExpStartMasterEngine(t *testing.T) {
if _, err := engine.StopStartEngine(cdrsMasterCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testCDRsOnExpStartMasterEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(cdrsMasterCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testCDRsOnExpStartSlaveEngine(t *testing.T) {
if _, err := engine.StartEngine(cdrsSlaveCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testCDRsOnExpStartSlaveEngine(t *testing.T) {
// if _, err := engine.StartEngine(cdrsSlaveCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
// Create Queues dor amq
// // Create Queues dor amq
func testCDRsOnExpAMQPQueuesCreation(t *testing.T) {
conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
if err != nil {
t.Fatal(err)
}
// func testCDRsOnExpAMQPQueuesCreation(t *testing.T) {
// conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
// if err != nil {
// t.Fatal(err)
// }
ch, err := conn.Channel()
if err != nil {
t.Fatal(err)
}
defer ch.Close()
// ch, err := conn.Channel()
// if err != nil {
// t.Fatal(err)
// }
// defer ch.Close()
if err = ch.ExchangeDeclare("exchangename", "fanout", true, false, false, false, nil); err != nil {
return
}
q1, err := ch.QueueDeclare("queue1", true, false, false, false, nil)
if err != nil {
t.Fatal(err)
}
if err = ch.QueueBind(q1.Name, "cgr_cdrs", "exchangename", false, nil); err != nil {
t.Fatal(err)
}
if err = ch.Close(); err != nil {
t.Error(err)
}
if err = conn.Close(); err != nil {
t.Error(err)
}
v, err := kafka.Dial("tcp", "localhost:9092")
if err != nil {
t.Fatal(err)
}
if err := v.CreateTopics(kafka.TopicConfig{
Topic: "cgrates_cdrs",
NumPartitions: 1,
ReplicationFactor: 1,
}); err != nil {
t.Fatal(err)
}
if err = v.Close(); err != nil {
t.Fatal(err)
}
}
// if err = ch.ExchangeDeclare("exchangename", "fanout", true, false, false, false, nil); err != nil {
// return
// }
// q1, err := ch.QueueDeclare("queue1", true, false, false, false, nil)
// if err != nil {
// t.Fatal(err)
// }
// if err = ch.QueueBind(q1.Name, "cgr_cdrs", "exchangename", false, nil); err != nil {
// t.Fatal(err)
// }
// if err = ch.Close(); err != nil {
// t.Error(err)
// }
// if err = conn.Close(); err != nil {
// t.Error(err)
// }
// v, err := kafka.Dial("tcp", "localhost:9092")
// if err != nil {
// t.Fatal(err)
// }
// if err := v.CreateTopics(kafka.TopicConfig{
// Topic: "cgrates_cdrs",
// NumPartitions: 1,
// ReplicationFactor: 1,
// }); err != nil {
// t.Fatal(err)
// }
// if err = v.Close(); err != nil {
// t.Fatal(err)
// }
// }
// Connect rpc client to rater
func testCDRsOnExpInitMasterRPC(t *testing.T) {
var err error
cdrsMasterRpc, err = rpcclient.NewRPCClient(context.Background(), utils.TCP, cdrsMasterCfg.ListenCfg().RPCJSONListen, false, "", "", "", 1, 1,
time.Second, 5*time.Second, rpcclient.JSONrpc, nil, false, nil)
if err != nil {
t.Fatal("Could not connect to rater: ", err.Error())
}
}
// // Connect rpc client to rater
// func testCDRsOnExpInitMasterRPC(t *testing.T) {
// var err error
// cdrsMasterRpc, err = rpcclient.NewRPCClient(context.Background(), utils.TCP, cdrsMasterCfg.ListenCfg().RPCJSONListen, false, "", "", "", 1, 1,
// time.Second, 5*time.Second, rpcclient.JSONrpc, nil, false, nil)
// if err != nil {
// t.Fatal("Could not connect to rater: ", err.Error())
// }
// }
func testCDRsOnExpLoadDefaultCharger(t *testing.T) {
// //add a default charger
chargerProfile := &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "Default",
RunID: utils.MetaDefault,
AttributeIDs: []string{"*none"},
Weight: 20,
}
var result string
if err := cdrsMasterRpc.Call(context.Background(), utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
}
// func testCDRsOnExpLoadDefaultCharger(t *testing.T) {
// // //add a default charger
// chargerProfile := &engine.ChargerProfile{
// Tenant: "cgrates.org",
// ID: "Default",
// RunID: utils.MetaDefault,
// AttributeIDs: []string{"*none"},
// Weight: 20,
// }
// var result string
// if err := cdrsMasterRpc.Call(context.Background(), utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
// }
// Disable ExportCDR
func testCDRsOnExpDisableOnlineExport(t *testing.T) {
testCdr := &engine.CDR{
CGRID: utils.Sha1("NoOnlineExport", time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC).String()),
ToR: utils.MetaVoice,
OriginID: "TestCDRsOnExpDisableOnlineExport",
OriginHost: "192.168.1.0",
Source: "UNKNOWN",
RequestType: utils.MetaPseudoPrepaid,
Tenant: "cgrates.org",
Category: "call",
Account: "1001",
Subject: "1001",
Destination: "1002",
SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC),
AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
Usage: 10 * time.Second,
ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
RunID: utils.MetaDefault,
Cost: 1.201,
PreRated: true,
// CostDetails: &engine.EventCost{
// Cost: utils.Float64Pointer(10),
// },
}
testEv := testCdr.AsCGREvent()
testEv.APIOpts[utils.OptsCDRsExport] = false
testEv.APIOpts[utils.OptsChargerS] = false
var reply string
if err := cdrsMasterRpc.Call(context.Background(), utils.CDRsV1ProcessEvent,
testEv, &reply); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if reply != utils.OK {
t.Error("Unexpected reply received: ", reply)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond)
filesInDir, _ := os.ReadDir(cdrsMasterCfg.GeneralCfg().FailedPostsDir)
if len(filesInDir) != 0 {
t.Fatalf("Should be no files in directory: %s", cdrsMasterCfg.GeneralCfg().FailedPostsDir)
}
}
// // Disable ExportCDR
// func testCDRsOnExpDisableOnlineExport(t *testing.T) {
// testCdr := &engine.CDR{
// CGRID: utils.Sha1("NoOnlineExport", time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC).String()),
// ToR: utils.MetaVoice,
// OriginID: "TestCDRsOnExpDisableOnlineExport",
// OriginHost: "192.168.1.0",
// Source: "UNKNOWN",
// RequestType: utils.MetaPseudoPrepaid,
// Tenant: "cgrates.org",
// Category: "call",
// Account: "1001",
// Subject: "1001",
// Destination: "1002",
// SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC),
// AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
// Usage: 10 * time.Second,
// ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
// RunID: utils.MetaDefault,
// Cost: 1.201,
// PreRated: true,
// // CostDetails: &engine.EventCost{
// // Cost: utils.Float64Pointer(10),
// // },
// }
// testEv := testCdr.AsCGREvent()
// testEv.APIOpts[utils.OptsCDRsExport] = false
// testEv.APIOpts[utils.OptsChargerS] = false
// var reply string
// if err := cdrsMasterRpc.Call(context.Background(), utils.CDRsV1ProcessEvent,
// testEv, &reply); err != nil {
// t.Error("Unexpected error: ", err.Error())
// } else if reply != utils.OK {
// t.Error("Unexpected reply received: ", reply)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond)
// filesInDir, _ := os.ReadDir(cdrsMasterCfg.GeneralCfg().FailedPostsDir)
// if len(filesInDir) != 0 {
// t.Fatalf("Should be no files in directory: %s", cdrsMasterCfg.GeneralCfg().FailedPostsDir)
// }
// }
func testCDRsOnExpHttpCdrReplication(t *testing.T) {
testCdr1 := &engine.CDR{
CGRID: httpCGRID,
ToR: utils.MetaVoice,
OriginID: "httpjsonrpc1",
OriginHost: "192.168.1.1",
Source: "UNKNOWN",
RequestType: utils.MetaNone,
Tenant: "cgrates.org",
Category: "call",
Account: "1001",
Subject: "1001",
Destination: "1002",
SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC),
AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
Usage: 10 * time.Second,
ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
RunID: utils.MetaDefault,
Cost: 1.201,
PreRated: true,
// CostDetails: &engine.EventCost{
// Cost: utils.Float64Pointer(10),
// },
}
var reply string
arg := testCdr1.AsCGREvent()
arg.APIOpts = map[string]interface{}{"ExporterID": "http_localhost"}
// func testCDRsOnExpHttpCdrReplication(t *testing.T) {
// testCdr1 := &engine.CDR{
// CGRID: httpCGRID,
// ToR: utils.MetaVoice,
// OriginID: "httpjsonrpc1",
// OriginHost: "192.168.1.1",
// Source: "UNKNOWN",
// RequestType: utils.MetaNone,
// Tenant: "cgrates.org",
// Category: "call",
// Account: "1001",
// Subject: "1001",
// Destination: "1002",
// SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC),
// AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
// Usage: 10 * time.Second,
// ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
// RunID: utils.MetaDefault,
// Cost: 1.201,
// PreRated: true,
// // CostDetails: &engine.EventCost{
// // Cost: utils.Float64Pointer(10),
// // },
// }
// var reply string
// arg := testCdr1.AsCGREvent()
// arg.APIOpts = map[string]interface{}{"ExporterID": "http_localhost"}
// we expect that the cdr export to fail and go into the failed post directory
if err := cdrsMasterRpc.Call(context.Background(), utils.CDRsV1ProcessEvent,
arg, &reply); err == nil || err.Error() != utils.ErrPartiallyExecuted.Error() {
t.Error("Unexpected error: ", err)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond)
cdrsSlaveRpc, err := rpcclient.NewRPCClient(context.Background(), utils.TCP, "127.0.0.1:12012", false, "", "", "", 1, 1,
time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil)
if err != nil {
t.Fatal("Could not connect to rater: ", err.Error())
}
// ToDo: Fix cdr_http to be compatible with rest of processCdr methods
var rcvedCdrs []*engine.ExternalCDR
if err := cdrsSlaveRpc.Call(utils.APIerSv2GetCDRs,
&utils.RPCCDRsFilter{CGRIDs: []string{testCdr1.CGRID}, RunIDs: []string{utils.MetaDefault}}, &rcvedCdrs); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if len(rcvedCdrs) != 1 {
t.Error("Unexpected number of CDRs returned: ", len(rcvedCdrs))
} else {
rcvSetupTime, _ := utils.ParseTimeDetectLayout(rcvedCdrs[0].SetupTime, "")
rcvAnswerTime, _ := utils.ParseTimeDetectLayout(rcvedCdrs[0].AnswerTime, "")
if rcvedCdrs[0].CGRID != testCdr1.CGRID ||
rcvedCdrs[0].RunID != testCdr1.RunID ||
rcvedCdrs[0].ToR != testCdr1.ToR ||
rcvedCdrs[0].OriginID != testCdr1.OriginID ||
rcvedCdrs[0].RequestType != testCdr1.RequestType ||
rcvedCdrs[0].Tenant != testCdr1.Tenant ||
rcvedCdrs[0].Category != testCdr1.Category ||
rcvedCdrs[0].Account != testCdr1.Account ||
rcvedCdrs[0].Subject != testCdr1.Subject ||
rcvedCdrs[0].Destination != testCdr1.Destination ||
!rcvSetupTime.Equal(testCdr1.SetupTime) ||
!rcvAnswerTime.Equal(testCdr1.AnswerTime) ||
rcvedCdrs[0].Usage != testCdr1.Usage.String() ||
rcvedCdrs[0].Cost != testCdr1.Cost {
t.Errorf("Expected: %+v, received: %+v", utils.ToJSON(testCdr1), utils.ToJSON(rcvedCdrs[0]))
}
}
}
// // we expect that the cdr export to fail and go into the failed post directory
// if err := cdrsMasterRpc.Call(context.Background(), utils.CDRsV1ProcessEvent,
// arg, &reply); err == nil || err.Error() != utils.ErrPartiallyExecuted.Error() {
// t.Error("Unexpected error: ", err)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond)
// cdrsSlaveRpc, err := rpcclient.NewRPCClient(context.Background(), utils.TCP, "127.0.0.1:12012", false, "", "", "", 1, 1,
// time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil)
// if err != nil {
// t.Fatal("Could not connect to rater: ", err.Error())
// }
// // ToDo: Fix cdr_http to be compatible with rest of processCdr methods
// var rcvedCdrs []*engine.ExternalCDR
// if err := cdrsSlaveRpc.Call(utils.APIerSv2GetCDRs,
// &utils.RPCCDRsFilter{CGRIDs: []string{testCdr1.CGRID}, RunIDs: []string{utils.MetaDefault}}, &rcvedCdrs); err != nil {
// t.Error("Unexpected error: ", err.Error())
// } else if len(rcvedCdrs) != 1 {
// t.Error("Unexpected number of CDRs returned: ", len(rcvedCdrs))
// } else {
// rcvSetupTime, _ := utils.ParseTimeDetectLayout(rcvedCdrs[0].SetupTime, "")
// rcvAnswerTime, _ := utils.ParseTimeDetectLayout(rcvedCdrs[0].AnswerTime, "")
// if rcvedCdrs[0].CGRID != testCdr1.CGRID ||
// rcvedCdrs[0].RunID != testCdr1.RunID ||
// rcvedCdrs[0].ToR != testCdr1.ToR ||
// rcvedCdrs[0].OriginID != testCdr1.OriginID ||
// rcvedCdrs[0].RequestType != testCdr1.RequestType ||
// rcvedCdrs[0].Tenant != testCdr1.Tenant ||
// rcvedCdrs[0].Category != testCdr1.Category ||
// rcvedCdrs[0].Account != testCdr1.Account ||
// rcvedCdrs[0].Subject != testCdr1.Subject ||
// rcvedCdrs[0].Destination != testCdr1.Destination ||
// !rcvSetupTime.Equal(testCdr1.SetupTime) ||
// !rcvAnswerTime.Equal(testCdr1.AnswerTime) ||
// rcvedCdrs[0].Usage != testCdr1.Usage.String() ||
// rcvedCdrs[0].Cost != testCdr1.Cost {
// t.Errorf("Expected: %+v, received: %+v", utils.ToJSON(testCdr1), utils.ToJSON(rcvedCdrs[0]))
// }
// }
// }
func testCDRsOnExpAMQPReplication(t *testing.T) {
conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
if err != nil {
t.Fatal(err)
}
// func testCDRsOnExpAMQPReplication(t *testing.T) {
// conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
// if err != nil {
// t.Fatal(err)
// }
ch, err := conn.Channel()
if err != nil {
t.Fatal(err)
}
defer ch.Close()
// ch, err := conn.Channel()
// if err != nil {
// t.Fatal(err)
// }
// defer ch.Close()
msgs, err := ch.Consume("cgrates_cdrs", "", true, false, false, false, nil)
if err != nil {
conn.Close()
t.Fatal(err)
}
select {
case d := <-msgs:
var rcvCDR map[string]string
if err := json.Unmarshal(d.Body, &rcvCDR); err != nil {
t.Error(err)
}
if rcvCDR[utils.CGRID] != httpCGRID {
t.Errorf("Unexpected CDR received: %+v", rcvCDR)
}
case <-time.After(100 * time.Millisecond):
t.Error("No message received from RabbitMQ")
}
if msgs, err = ch.Consume("queue1", "consumer", true, false, false, false, nil); err != nil {
conn.Close()
t.Fatal(err)
}
select {
case d := <-msgs:
var rcvCDR map[string]string
if err := json.Unmarshal(d.Body, &rcvCDR); err != nil {
t.Error(err)
}
if rcvCDR[utils.CGRID] != httpCGRID {
t.Errorf("Unexpected CDR received: %+v", rcvCDR)
}
case <-time.After(100 * time.Millisecond):
t.Error("No message received from RabbitMQ")
}
conn.Close()
// restart RabbitMQ server so we can test reconnects
if err := exec.Command("service", "rabbitmq-server", "restart").Run(); err != nil {
t.Error(err)
}
time.Sleep(2 * time.Second)
testCdr := &engine.CDR{
CGRID: amqpCGRID,
ToR: utils.MetaVoice,
OriginID: "amqpreconnect",
OriginHost: "192.168.1.1",
Source: "UNKNOWN",
RequestType: utils.MetaPseudoPrepaid,
Tenant: "cgrates.org",
Category: "call",
Account: "1001",
Subject: "1001",
Destination: "1002",
SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC),
AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
Usage: 10 * time.Second,
ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
RunID: utils.MetaDefault,
Cost: 1.201,
PreRated: true,
// CostDetails: &engine.EventCost{
// Cost: utils.Float64Pointer(10),
// },
}
testEv := testCdr.AsCGREvent()
testEv.APIOpts[utils.OptsCDRsExport] = true
var reply string
if err := cdrsMasterRpc.Call(context.Background(), utils.CDRsV1ProcessEvent,
testEv, &reply); err == nil || err.Error() != utils.ErrPartiallyExecuted.Error() {
t.Error("Unexpected error: ", err)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond)
if conn, err = amqp.Dial("amqp://guest:guest@localhost:5672/"); err != nil {
t.Fatal(err)
}
defer conn.Close()
// msgs, err := ch.Consume("cgrates_cdrs", "", true, false, false, false, nil)
// if err != nil {
// conn.Close()
// t.Fatal(err)
// }
// select {
// case d := <-msgs:
// var rcvCDR map[string]string
// if err := json.Unmarshal(d.Body, &rcvCDR); err != nil {
// t.Error(err)
// }
// if rcvCDR[utils.CGRID] != httpCGRID {
// t.Errorf("Unexpected CDR received: %+v", rcvCDR)
// }
// case <-time.After(100 * time.Millisecond):
// t.Error("No message received from RabbitMQ")
// }
// if msgs, err = ch.Consume("queue1", "consumer", true, false, false, false, nil); err != nil {
// conn.Close()
// t.Fatal(err)
// }
// select {
// case d := <-msgs:
// var rcvCDR map[string]string
// if err := json.Unmarshal(d.Body, &rcvCDR); err != nil {
// t.Error(err)
// }
// if rcvCDR[utils.CGRID] != httpCGRID {
// t.Errorf("Unexpected CDR received: %+v", rcvCDR)
// }
// case <-time.After(100 * time.Millisecond):
// t.Error("No message received from RabbitMQ")
// }
// conn.Close()
// // restart RabbitMQ server so we can test reconnects
// if err := exec.Command("service", "rabbitmq-server", "restart").Run(); err != nil {
// t.Error(err)
// }
// time.Sleep(2 * time.Second)
// testCdr := &engine.CDR{
// CGRID: amqpCGRID,
// ToR: utils.MetaVoice,
// OriginID: "amqpreconnect",
// OriginHost: "192.168.1.1",
// Source: "UNKNOWN",
// RequestType: utils.MetaPseudoPrepaid,
// Tenant: "cgrates.org",
// Category: "call",
// Account: "1001",
// Subject: "1001",
// Destination: "1002",
// SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC),
// AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
// Usage: 10 * time.Second,
// ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
// RunID: utils.MetaDefault,
// Cost: 1.201,
// PreRated: true,
// // CostDetails: &engine.EventCost{
// // Cost: utils.Float64Pointer(10),
// // },
// }
// testEv := testCdr.AsCGREvent()
// testEv.APIOpts[utils.OptsCDRsExport] = true
// var reply string
// if err := cdrsMasterRpc.Call(context.Background(), utils.CDRsV1ProcessEvent,
// testEv, &reply); err == nil || err.Error() != utils.ErrPartiallyExecuted.Error() {
// t.Error("Unexpected error: ", err)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond)
// if conn, err = amqp.Dial("amqp://guest:guest@localhost:5672/"); err != nil {
// t.Fatal(err)
// }
// defer conn.Close()
if ch, err = conn.Channel(); err != nil {
t.Fatal(err)
}
defer ch.Close()
// if ch, err = conn.Channel(); err != nil {
// t.Fatal(err)
// }
// defer ch.Close()
if msgs, err = ch.Consume("cgrates_cdrs", "", true, false, false, false, nil); err != nil {
t.Fatal(err)
}
select {
case d := <-msgs:
var rcvCDR map[string]string
if err := json.Unmarshal(d.Body, &rcvCDR); err != nil {
t.Error(err)
}
if rcvCDR[utils.CGRID] != testCdr.CGRID {
t.Errorf("Unexpected CDR received: %+v", rcvCDR)
}
case <-time.After(150 * time.Millisecond):
t.Error("No message received from RabbitMQ")
}
// if msgs, err = ch.Consume("cgrates_cdrs", "", true, false, false, false, nil); err != nil {
// t.Fatal(err)
// }
// select {
// case d := <-msgs:
// var rcvCDR map[string]string
// if err := json.Unmarshal(d.Body, &rcvCDR); err != nil {
// t.Error(err)
// }
// if rcvCDR[utils.CGRID] != testCdr.CGRID {
// t.Errorf("Unexpected CDR received: %+v", rcvCDR)
// }
// case <-time.After(150 * time.Millisecond):
// t.Error("No message received from RabbitMQ")
// }
if msgs, err = ch.Consume("queue1", "", true, false, false, false, nil); err != nil {
t.Fatal(err)
}
select {
case d := <-msgs:
var rcvCDR map[string]string
if err := json.Unmarshal(d.Body, &rcvCDR); err != nil {
t.Error(err)
}
if rcvCDR[utils.CGRID] != testCdr.CGRID {
t.Errorf("Unexpected CDR received: %s expeced: %s", utils.ToJSON(rcvCDR), utils.ToJSON(testCdr))
}
case <-time.After(150 * time.Millisecond):
t.Error("No message received from RabbitMQ")
}
// if msgs, err = ch.Consume("queue1", "", true, false, false, false, nil); err != nil {
// t.Fatal(err)
// }
// select {
// case d := <-msgs:
// var rcvCDR map[string]string
// if err := json.Unmarshal(d.Body, &rcvCDR); err != nil {
// t.Error(err)
// }
// if rcvCDR[utils.CGRID] != testCdr.CGRID {
// t.Errorf("Unexpected CDR received: %s expeced: %s", utils.ToJSON(rcvCDR), utils.ToJSON(testCdr))
// }
// case <-time.After(150 * time.Millisecond):
// t.Error("No message received from RabbitMQ")
// }
}
// }
func testCDRsOnExpFileFailover(t *testing.T) {
v1 := url.Values{}
v2 := url.Values{}
v1.Set("OriginID", "httpjsonrpc1")
v2.Set("OriginID", "amqpreconnect")
httpContent := []interface{}{&ees.HTTPPosterRequest{Body: v1, Header: http.Header{"Content-Type": []string{"application/x-www-form-urlencoded"}}},
&ees.HTTPPosterRequest{Body: v2, Header: http.Header{"Content-Type": []string{"application/x-www-form-urlencoded"}}}}
filesInDir, _ := os.ReadDir(cdrsMasterCfg.GeneralCfg().FailedPostsDir)
if len(filesInDir) == 0 {
t.Fatalf("No files in directory: %s", cdrsMasterCfg.GeneralCfg().FailedPostsDir)
}
for _, file := range filesInDir { // First file in directory is the one we need, harder to find it's name out of config
fileName := file.Name()
filePath := path.Join(cdrsMasterCfg.GeneralCfg().FailedPostsDir, fileName)
// func testCDRsOnExpFileFailover(t *testing.T) {
// v1 := url.Values{}
// v2 := url.Values{}
// v1.Set("OriginID", "httpjsonrpc1")
// v2.Set("OriginID", "amqpreconnect")
// httpContent := []interface{}{&ees.HTTPPosterRequest{Body: v1, Header: http.Header{"Content-Type": []string{"application/x-www-form-urlencoded"}}},
// &ees.HTTPPosterRequest{Body: v2, Header: http.Header{"Content-Type": []string{"application/x-www-form-urlencoded"}}}}
// filesInDir, _ := os.ReadDir(cdrsMasterCfg.GeneralCfg().FailedPostsDir)
// if len(filesInDir) == 0 {
// t.Fatalf("No files in directory: %s", cdrsMasterCfg.GeneralCfg().FailedPostsDir)
// }
// for _, file := range filesInDir { // First file in directory is the one we need, harder to find it's name out of config
// fileName := file.Name()
// filePath := path.Join(cdrsMasterCfg.GeneralCfg().FailedPostsDir, fileName)
ev, err := ees.NewExportEventsFromFile(filePath)
if err != nil {
t.Errorf("<%s> for file <%s>", err, fileName)
continue
} else if len(ev.Events) == 0 {
t.Error("Expected at least one event")
continue
}
if ev.Format != utils.MetaHTTPPost {
t.Errorf("Expected %s to be only failed exporter,received <%s>", utils.MetaHTTPPost, ev.Format)
}
if err := checkContent(ev, httpContent); err != nil {
t.Errorf("For file <%s> and event <%s> received %s", filePath, utils.ToJSON(ev), err)
}
}
}
// ev, err := ees.NewExportEventsFromFile(filePath)
// if err != nil {
// t.Errorf("<%s> for file <%s>", err, fileName)
// continue
// } else if len(ev.Events) == 0 {
// t.Error("Expected at least one event")
// continue
// }
// if ev.Format != utils.MetaHTTPPost {
// t.Errorf("Expected %s to be only failed exporter,received <%s>", utils.MetaHTTPPost, ev.Format)
// }
// if err := checkContent(ev, httpContent); err != nil {
// t.Errorf("For file <%s> and event <%s> received %s", filePath, utils.ToJSON(ev), err)
// }
// }
// }
func testCDRsOnExpKafkaPosterFileFailover(t *testing.T) {
reader := kafka.NewReader(kafka.ReaderConfig{
Brokers: []string{"localhost:9092"},
Topic: "cgrates_cdrs",
GroupID: "tmp",
MaxWait: time.Millisecond,
})
// func testCDRsOnExpKafkaPosterFileFailover(t *testing.T) {
// reader := kafka.NewReader(kafka.ReaderConfig{
// Brokers: []string{"localhost:9092"},
// Topic: "cgrates_cdrs",
// GroupID: "tmp",
// MaxWait: time.Millisecond,
// })
defer reader.Close()
// defer reader.Close()
for i := 0; i < 2; i++ { // no raw CDR
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
if m, err := reader.ReadMessage(ctx); err != nil {
t.Fatal(err)
} else if !reflect.DeepEqual(failoverContent[0], m.Value) && !reflect.DeepEqual(failoverContent[1], m.Value) { // Checking just the prefix should do since some content is dynamic
t.Errorf("Expecting: %v or %v, received: %v", string(failoverContent[0]), string(failoverContent[1]), string(m.Value))
}
cancel()
}
}
// for i := 0; i < 2; i++ { // no raw CDR
// ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
// if m, err := reader.ReadMessage(ctx); err != nil {
// t.Fatal(err)
// } else if !reflect.DeepEqual(failoverContent[0], m.Value) && !reflect.DeepEqual(failoverContent[1], m.Value) { // Checking just the prefix should do since some content is dynamic
// t.Errorf("Expecting: %v or %v, received: %v", string(failoverContent[0]), string(failoverContent[1]), string(m.Value))
// }
// cancel()
// }
// }
func testCDRsOnExpStopEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
if err != nil {
t.Fatal(err)
}
// func testCDRsOnExpStopEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
// if err != nil {
// t.Fatal(err)
// }
ch, err := conn.Channel()
if err != nil {
t.Fatal(err)
}
defer ch.Close()
// ch, err := conn.Channel()
// if err != nil {
// t.Fatal(err)
// }
// defer ch.Close()
if _, err = ch.QueueDelete("cgrates_cdrs", false, false, true); err != nil {
t.Fatal(err)
}
// if _, err = ch.QueueDelete("cgrates_cdrs", false, false, true); err != nil {
// t.Fatal(err)
// }
if _, err = ch.QueueDelete("queue1", false, false, true); err != nil {
t.Fatal(err)
}
}
// if _, err = ch.QueueDelete("queue1", false, false, true); err != nil {
// t.Fatal(err)
// }
// }

374
general_tests/cdrs_post_failover_it_test.go
View File

@@ -21,206 +21,206 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"os"
"path"
"testing"
"time"
// import (
// "net/rpc"
// "os"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/ees"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/ees"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
cdrsPostFailCfgPath string
cdrsPostFailCfg *config.CGRConfig
cdrsPostFailRpc *rpc.Client
cdrsPostFailConfDIR string // run the tests for specific configuration
// var (
// cdrsPostFailCfgPath string
// cdrsPostFailCfg *config.CGRConfig
// cdrsPostFailRpc *rpc.Client
// cdrsPostFailConfDIR string // run the tests for specific configuration
// subtests to be executed for each confDIR
sTestsCDRsPostFailIT = []func(t *testing.T){
testCDRsPostFailoverInitConfig,
testCDRsPostFailoverInitDataDb,
testCDRsPostFailoverInitCdrDb,
testCDRsPostFailoverStartEngine,
testCDRsPostFailoverRpcConn,
testCDRsPostFailoverLoadTariffPlanFromFolder,
testCDRsPostFailoverProcessCDR,
testCDRsPostFailoverToFile,
testCDRsPostFailoverKillEngine,
}
)
// // subtests to be executed for each confDIR
// sTestsCDRsPostFailIT = []func(t *testing.T){
// testCDRsPostFailoverInitConfig,
// testCDRsPostFailoverInitDataDb,
// testCDRsPostFailoverInitCdrDb,
// testCDRsPostFailoverStartEngine,
// testCDRsPostFailoverRpcConn,
// testCDRsPostFailoverLoadTariffPlanFromFolder,
// testCDRsPostFailoverProcessCDR,
// testCDRsPostFailoverToFile,
// testCDRsPostFailoverKillEngine,
// }
// )
// Tests starting here
func TestCDRsPostFailoverIT(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
cdrsPostFailConfDIR = "cdrsv_failover_internal"
case utils.MetaMySQL:
cdrsPostFailConfDIR = "cdrsv_failover_mysql"
case utils.MetaMongo:
cdrsPostFailConfDIR = "cdrsv_failover_mongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
// // Tests starting here
// func TestCDRsPostFailoverIT(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// cdrsPostFailConfDIR = "cdrsv_failover_internal"
// case utils.MetaMySQL:
// cdrsPostFailConfDIR = "cdrsv_failover_mysql"
// case utils.MetaMongo:
// cdrsPostFailConfDIR = "cdrsv_failover_mongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
for _, stest := range sTestsCDRsPostFailIT {
t.Run(cdrsPostFailConfDIR, stest)
}
}
// for _, stest := range sTestsCDRsPostFailIT {
// t.Run(cdrsPostFailConfDIR, stest)
// }
// }
func testCDRsPostFailoverInitConfig(t *testing.T) {
var err error
cdrsPostFailCfgPath = path.Join(*dataDir, "conf", "samples", cdrsPostFailConfDIR)
if cdrsPostFailCfg, err = config.NewCGRConfigFromPath(cdrsPostFailCfgPath); err != nil {
t.Fatal("Got config error: ", err.Error())
}
if err = os.RemoveAll(cdrsPostFailCfg.GeneralCfg().FailedPostsDir); err != nil {
t.Error(err)
}
if err = os.MkdirAll(cdrsPostFailCfg.GeneralCfg().FailedPostsDir, 0755); err != nil {
t.Error(err)
}
}
// func testCDRsPostFailoverInitConfig(t *testing.T) {
// var err error
// cdrsPostFailCfgPath = path.Join(*dataDir, "conf", "samples", cdrsPostFailConfDIR)
// if cdrsPostFailCfg, err = config.NewCGRConfigFromPath(cdrsPostFailCfgPath); err != nil {
// t.Fatal("Got config error: ", err.Error())
// }
// if err = os.RemoveAll(cdrsPostFailCfg.GeneralCfg().FailedPostsDir); err != nil {
// t.Error(err)
// }
// if err = os.MkdirAll(cdrsPostFailCfg.GeneralCfg().FailedPostsDir, 0755); err != nil {
// t.Error(err)
// }
// }
func testCDRsPostFailoverInitDataDb(t *testing.T) {
if err := engine.InitDataDB(cdrsPostFailCfg); err != nil {
t.Fatal(err)
}
}
// func testCDRsPostFailoverInitDataDb(t *testing.T) {
// if err := engine.InitDataDB(cdrsPostFailCfg); err != nil {
// t.Fatal(err)
// }
// }
// InitDb so we can rely on count
func testCDRsPostFailoverInitCdrDb(t *testing.T) {
if err := engine.InitStorDB(cdrsPostFailCfg); err != nil {
t.Fatal(err)
}
}
// // InitDb so we can rely on count
// func testCDRsPostFailoverInitCdrDb(t *testing.T) {
// if err := engine.InitStorDB(cdrsPostFailCfg); err != nil {
// t.Fatal(err)
// }
// }
func testCDRsPostFailoverStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(cdrsPostFailCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testCDRsPostFailoverStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(cdrsPostFailCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
// Connect rpc client to rater
func testCDRsPostFailoverRpcConn(t *testing.T) {
cdrsPostFailRpc, err = newRPCClient(cdrsPostFailCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal("Could not connect to rater: ", err.Error())
}
}
// // Connect rpc client to rater
// func testCDRsPostFailoverRpcConn(t *testing.T) {
// cdrsPostFailRpc, err = newRPCClient(cdrsPostFailCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal("Could not connect to rater: ", err.Error())
// }
// }
func testCDRsPostFailoverLoadTariffPlanFromFolder(t *testing.T) {
var loadInst utils.LoadInstance
if err := cdrsPostFailRpc.Call(utils.APIerSv2LoadTariffPlanFromFolder,
&utils.AttrLoadTpFromFolder{FolderPath: path.Join(
*dataDir, "tariffplans", "testit")}, &loadInst); err != nil {
t.Error(err)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups
var resp string
if err := cdrsPostFailRpc.Call(utils.APIerSv1RemoveChargerProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "SupplierCharges"}, &resp); err != nil {
t.Error(err)
} else if resp != utils.OK {
t.Error("Unexpected reply returned", resp)
}
var reply *engine.ChargerProfile
if err := cdrsPostFailRpc.Call(utils.APIerSv1GetChargerProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "SupplierCharges"},
&reply); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
// func testCDRsPostFailoverLoadTariffPlanFromFolder(t *testing.T) {
// var loadInst utils.LoadInstance
// if err := cdrsPostFailRpc.Call(utils.APIerSv2LoadTariffPlanFromFolder,
// &utils.AttrLoadTpFromFolder{FolderPath: path.Join(
// *dataDir, "tariffplans", "testit")}, &loadInst); err != nil {
// t.Error(err)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups
// var resp string
// if err := cdrsPostFailRpc.Call(utils.APIerSv1RemoveChargerProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "SupplierCharges"}, &resp); err != nil {
// t.Error(err)
// } else if resp != utils.OK {
// t.Error("Unexpected reply returned", resp)
// }
// var reply *engine.ChargerProfile
// if err := cdrsPostFailRpc.Call(utils.APIerSv1GetChargerProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "SupplierCharges"},
// &reply); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// }
func testCDRsPostFailoverProcessCDR(t *testing.T) {
args := &utils.CGREvent{
ID: "1",
Tenant: "cgrates.org",
Event: map[string]interface{}{
utils.OriginID: "testCDRsPostFailoverProcessCDR",
utils.OriginHost: "192.168.1.1",
utils.Source: "testCDRsPostFailoverProcessCDR",
utils.RequestType: utils.MetaRated,
utils.Category: "call",
utils.AccountField: "testCDRsPostFailoverProcessCDR",
utils.Subject: "ANY2CNT",
utils.Destination: "+4986517174963",
utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
utils.Usage: time.Minute,
"field_extr1": "val_extr1",
"fieldextr2": "valextr2",
},
APIOpts: map[string]interface{}{
utils.OptsCDRsExport: true,
utils.OptsAttributeS: false,
// utils.MetaRalS:false,
utils.OptsChargerS: false,
utils.OptsCDRsStore: false,
utils.OptsThresholdS: false,
utils.OptsStatS: false,
},
}
// func testCDRsPostFailoverProcessCDR(t *testing.T) {
// args := &utils.CGREvent{
// ID: "1",
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// utils.OriginID: "testCDRsPostFailoverProcessCDR",
// utils.OriginHost: "192.168.1.1",
// utils.Source: "testCDRsPostFailoverProcessCDR",
// utils.RequestType: utils.MetaRated,
// utils.Category: "call",
// utils.AccountField: "testCDRsPostFailoverProcessCDR",
// utils.Subject: "ANY2CNT",
// utils.Destination: "+4986517174963",
// utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
// utils.Usage: time.Minute,
// "field_extr1": "val_extr1",
// "fieldextr2": "valextr2",
// },
// APIOpts: map[string]interface{}{
// utils.OptsCDRsExport: true,
// utils.OptsAttributeS: false,
// // utils.MetaRalS:false,
// utils.OptsChargerS: false,
// utils.OptsCDRsStore: false,
// utils.OptsThresholdS: false,
// utils.OptsStatS: false,
// },
// }
var reply string
if err := cdrsPostFailRpc.Call(utils.CDRsV1ProcessEvent, args, &reply); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if reply != utils.OK {
t.Error("Unexpected reply received: ", reply)
}
args.ID = "2"
args.Event[utils.OriginID] = "2"
if err := cdrsPostFailRpc.Call(utils.CDRsV1ProcessEvent, args, &reply); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if reply != utils.OK {
t.Error("Unexpected reply received: ", reply)
}
args.ID = "3"
args.Event[utils.OriginID] = "3"
if err := cdrsPostFailRpc.Call(utils.CDRsV1ProcessEvent, args, &reply); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if reply != utils.OK {
t.Error("Unexpected reply received: ", reply)
}
}
// var reply string
// if err := cdrsPostFailRpc.Call(utils.CDRsV1ProcessEvent, args, &reply); err != nil {
// t.Error("Unexpected error: ", err.Error())
// } else if reply != utils.OK {
// t.Error("Unexpected reply received: ", reply)
// }
// args.ID = "2"
// args.Event[utils.OriginID] = "2"
// if err := cdrsPostFailRpc.Call(utils.CDRsV1ProcessEvent, args, &reply); err != nil {
// t.Error("Unexpected error: ", err.Error())
// } else if reply != utils.OK {
// t.Error("Unexpected reply received: ", reply)
// }
// args.ID = "3"
// args.Event[utils.OriginID] = "3"
// if err := cdrsPostFailRpc.Call(utils.CDRsV1ProcessEvent, args, &reply); err != nil {
// t.Error("Unexpected error: ", err.Error())
// } else if reply != utils.OK {
// t.Error("Unexpected reply received: ", reply)
// }
// }
func testCDRsPostFailoverToFile(t *testing.T) {
time.Sleep(2 * time.Second)
filesInDir, _ := os.ReadDir(cdrsPostFailCfg.GeneralCfg().FailedPostsDir)
if len(filesInDir) == 0 {
t.Fatalf("No files in directory: %s", cdrsPostFailCfg.GeneralCfg().FailedPostsDir)
}
for _, file := range filesInDir { // First file in directory is the one we need, harder to find it's name out of config
fileName := file.Name()
filePath := path.Join(cdrsPostFailCfg.GeneralCfg().FailedPostsDir, fileName)
// func testCDRsPostFailoverToFile(t *testing.T) {
// time.Sleep(2 * time.Second)
// filesInDir, _ := os.ReadDir(cdrsPostFailCfg.GeneralCfg().FailedPostsDir)
// if len(filesInDir) == 0 {
// t.Fatalf("No files in directory: %s", cdrsPostFailCfg.GeneralCfg().FailedPostsDir)
// }
// for _, file := range filesInDir { // First file in directory is the one we need, harder to find it's name out of config
// fileName := file.Name()
// filePath := path.Join(cdrsPostFailCfg.GeneralCfg().FailedPostsDir, fileName)
ev, err := ees.NewExportEventsFromFile(filePath)
if err != nil {
t.Errorf("<%s> for file <%s>", err, fileName)
continue
} else if len(ev.Events) == 0 {
t.Error("Expected at least one event")
continue
}
if ev.Format != utils.MetaS3jsonMap {
t.Errorf("Expected event to use %q received: %q", utils.MetaS3jsonMap, ev.Format)
}
if len(ev.Events) != 3 {
t.Errorf("Expected all the events to be saved in the same file, ony %v saved in this file.", len(ev.Events))
}
}
}
// ev, err := ees.NewExportEventsFromFile(filePath)
// if err != nil {
// t.Errorf("<%s> for file <%s>", err, fileName)
// continue
// } else if len(ev.Events) == 0 {
// t.Error("Expected at least one event")
// continue
// }
// if ev.Format != utils.MetaS3jsonMap {
// t.Errorf("Expected event to use %q received: %q", utils.MetaS3jsonMap, ev.Format)
// }
// if len(ev.Events) != 3 {
// t.Errorf("Expected all the events to be saved in the same file, ony %v saved in this file.", len(ev.Events))
// }
// }
// }
func testCDRsPostFailoverKillEngine(t *testing.T) {
if err = os.RemoveAll(cdrsPostFailCfg.GeneralCfg().FailedPostsDir); err != nil {
t.Error(err)
}
if err := engine.KillEngine(*waitRater); err != nil {
t.Error(err)
}
}
// func testCDRsPostFailoverKillEngine(t *testing.T) {
// if err = os.RemoveAll(cdrsPostFailCfg.GeneralCfg().FailedPostsDir); err != nil {
// t.Error(err)
// }
// if err := engine.KillEngine(*waitRater); err != nil {
// t.Error(err)
// }
// }

1302
general_tests/cdrs_processevent_it_test.go
View File

File diff suppressed because it is too large Load Diff

214
general_tests/cgrloader_it_test.go
View File

@@ -21,122 +21,122 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"flag"
"net/rpc"
"os/exec"
"path"
"testing"
// import (
// "flag"
// "net/rpc"
// "os/exec"
// "path"
// "testing"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
loaderGoogleSheet = flag.Bool("google_sheet", false, "Run the test with google sheet")
cgrloaderCfgPath string
cgrloaderCfg *config.CGRConfig
cgrloaderRPC *rpc.Client
cgrloaderConfDIR string //run tests for specific configuration
// var (
// loaderGoogleSheet = flag.Bool("google_sheet", false, "Run the test with google sheet")
// cgrloaderCfgPath string
// cgrloaderCfg *config.CGRConfig
// cgrloaderRPC *rpc.Client
// cgrloaderConfDIR string //run tests for specific configuration
sTestsCGRLoaders = []func(t *testing.T){
testCGRLoaderInitConfig,
testCGRLoaderInitDataDb,
testCGRLoaderInitCdrDb,
testCGRLoaderStartEngine,
testCGRLoaderRpcConn,
testCGRLoaderLoadData,
testCGRLoaderGetData,
testCGRLoaderKillEngine,
}
)
// sTestsCGRLoaders = []func(t *testing.T){
// testCGRLoaderInitConfig,
// testCGRLoaderInitDataDb,
// testCGRLoaderInitCdrDb,
// testCGRLoaderStartEngine,
// testCGRLoaderRpcConn,
// testCGRLoaderLoadData,
// testCGRLoaderGetData,
// testCGRLoaderKillEngine,
// }
// )
//Test start here
func TestCGRLoader(t *testing.T) {
if !*loaderGoogleSheet {
t.SkipNow()
return
}
switch *dbType {
case utils.MetaInternal:
t.SkipNow()
case utils.MetaMySQL:
cgrloaderConfDIR = "loader_mysql"
case utils.MetaMongo:
cgrloaderConfDIR = "loader_mongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestsCGRLoaders {
t.Run(cgrloaderConfDIR, stest)
}
}
// //Test start here
// func TestCGRLoader(t *testing.T) {
// if !*loaderGoogleSheet {
// t.SkipNow()
// return
// }
// switch *dbType {
// case utils.MetaInternal:
// t.SkipNow()
// case utils.MetaMySQL:
// cgrloaderConfDIR = "loader_mysql"
// case utils.MetaMongo:
// cgrloaderConfDIR = "loader_mongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sTestsCGRLoaders {
// t.Run(cgrloaderConfDIR, stest)
// }
// }
func testCGRLoaderInitConfig(t *testing.T) {
var err error
cgrloaderCfgPath = path.Join(*dataDir, "conf", "samples", cgrloaderConfDIR)
if cgrloaderCfg, err = config.NewCGRConfigFromPath(cgrloaderCfgPath); err != nil {
t.Fatal("Got config error: ", err.Error())
}
}
// func testCGRLoaderInitConfig(t *testing.T) {
// var err error
// cgrloaderCfgPath = path.Join(*dataDir, "conf", "samples", cgrloaderConfDIR)
// if cgrloaderCfg, err = config.NewCGRConfigFromPath(cgrloaderCfgPath); err != nil {
// t.Fatal("Got config error: ", err.Error())
// }
// }
func testCGRLoaderInitDataDb(t *testing.T) {
if err := engine.InitDataDB(cgrloaderCfg); err != nil {
t.Fatal(err)
}
}
// func testCGRLoaderInitDataDb(t *testing.T) {
// if err := engine.InitDataDB(cgrloaderCfg); err != nil {
// t.Fatal(err)
// }
// }
func testCGRLoaderInitCdrDb(t *testing.T) {
if err := engine.InitStorDB(cgrloaderCfg); err != nil {
t.Fatal(err)
}
}
// func testCGRLoaderInitCdrDb(t *testing.T) {
// if err := engine.InitStorDB(cgrloaderCfg); err != nil {
// t.Fatal(err)
// }
// }
func testCGRLoaderStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(cgrloaderCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testCGRLoaderStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(cgrloaderCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testCGRLoaderRpcConn(t *testing.T) {
var err error
cgrloaderRPC, err = newRPCClient(cgrloaderCfg.ListenCfg())
if err != nil {
t.Fatal("Could not connect to rater: ", err.Error())
}
}
// func testCGRLoaderRpcConn(t *testing.T) {
// var err error
// cgrloaderRPC, err = newRPCClient(cgrloaderCfg.ListenCfg())
// if err != nil {
// t.Fatal("Could not connect to rater: ", err.Error())
// }
// }
func testCGRLoaderLoadData(t *testing.T) {
loaderPath, err := exec.LookPath("cgr-loader")
if err != nil {
t.Fatal(err)
}
loader := exec.Command(loaderPath, "-config_path", cgrloaderCfgPath, "-path", "*gapi:1pRFnsFBlKeGnD3wysZ1CXxylZI7r_Zh5iZI99ViOyPM")
if err := loader.Start(); err != nil {
t.Fatal(err)
}
if err := loader.Wait(); err != nil {
t.Error(err)
}
}
// func testCGRLoaderLoadData(t *testing.T) {
// loaderPath, err := exec.LookPath("cgr-loader")
// if err != nil {
// t.Fatal(err)
// }
// loader := exec.Command(loaderPath, "-config_path", cgrloaderCfgPath, "-path", "*gapi:1pRFnsFBlKeGnD3wysZ1CXxylZI7r_Zh5iZI99ViOyPM")
// if err := loader.Start(); err != nil {
// t.Fatal(err)
// }
// if err := loader.Wait(); err != nil {
// t.Error(err)
// }
// }
func testCGRLoaderGetData(t *testing.T) {
expected := []string{"ATTR_1001_SIMPLEAUTH", "ATTR_1002_SIMPLEAUTH", "ATTR_1003_SIMPLEAUTH",
"ATTR_1001_SESSIONAUTH", "ATTR_1002_SESSIONAUTH", "ATTR_1003_SESSIONAUTH",
"ATTR_ACC_ALIAS"}
var result []string
if err := cgrloaderRPC.Call(utils.AdminSv1GetAttributeProfileIDs, &utils.PaginatorWithTenant{Tenant: "cgrates.org"}, &result); err != nil {
t.Error(err)
} else if len(expected) != len(result) {
t.Errorf("Expecting : %+v, received: %+v", expected, result)
}
}
// func testCGRLoaderGetData(t *testing.T) {
// expected := []string{"ATTR_1001_SIMPLEAUTH", "ATTR_1002_SIMPLEAUTH", "ATTR_1003_SIMPLEAUTH",
// "ATTR_1001_SESSIONAUTH", "ATTR_1002_SESSIONAUTH", "ATTR_1003_SESSIONAUTH",
// "ATTR_ACC_ALIAS"}
// var result []string
// if err := cgrloaderRPC.Call(utils.AdminSv1GetAttributeProfileIDs, &utils.PaginatorWithTenant{Tenant: "cgrates.org"}, &result); err != nil {
// t.Error(err)
// } else if len(expected) != len(result) {
// t.Errorf("Expecting : %+v, received: %+v", expected, result)
// }
// }
func testCGRLoaderKillEngine(t *testing.T) {
if err := engine.KillEngine(*waitRater); err != nil {
t.Error(err)
}
}
// func testCGRLoaderKillEngine(t *testing.T) {
// if err := engine.KillEngine(*waitRater); err != nil {
// t.Error(err)
// }
// }

1046
general_tests/data_it_test.go
View File

File diff suppressed because it is too large Load Diff

210
general_tests/dbl_tp_dif_it_test.go
View File

@@ -18,120 +18,120 @@ 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 <http://www.gnu.org/licenses/>
*/
package apis
package general_tests
import (
"fmt"
"os"
"path"
"testing"
// import (
// "fmt"
// "os"
// "path"
// "testing"
"github.com/cgrates/birpc"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/birpc"
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
testDblTpDifDestDir string
testDblTpDifDestPath string
testDblTpDifDestCfg *config.CGRConfig
testDblTpDifDestRPC *birpc.Client
// var (
// testDblTpDifDestDir string
// testDblTpDifDestPath string
// testDblTpDifDestCfg *config.CGRConfig
// testDblTpDifDestRPC *birpc.Client
testDblTpDifDestTests = []func(t *testing.T){
//testGenerateCsv,
// testDblTpDifDestLoadConfig,
// testDblTpDifDestResetDataDB,
// testDblTpDifDestResetStorDb,
// //testDblTpDifDestStartEngine,
// testDblTpDifDestRPCConn,
// testDblTpDifDestLoadersLoad,
//testDblTpDifDestStopCgrEngine,
}
)
// testDblTpDifDestTests = []func(t *testing.T){
// //testGenerateCsv,
// // testDblTpDifDestLoadConfig,
// // testDblTpDifDestResetDataDB,
// // testDblTpDifDestResetStorDb,
// // //testDblTpDifDestStartEngine,
// // testDblTpDifDestRPCConn,
// // testDblTpDifDestLoadersLoad,
// //testDblTpDifDestStopCgrEngine,
// }
// )
func TestDblTpDifDest(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
testDblTpDifDestDir = "dblTpDifInternal"
case utils.MetaMySQL:
testDblTpDifDestDir = "dblTpDifMySql"
case utils.MetaMongo:
testDblTpDifDestDir = "dblTpDifInternalMongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, testDblTpDifDest := range testDblTpDifDestTests {
t.Run(testDblTpDifDestDir, testDblTpDifDest)
}
}
// func TestDblTpDifDest(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// testDblTpDifDestDir = "dblTpDifInternal"
// case utils.MetaMySQL:
// testDblTpDifDestDir = "dblTpDifMySql"
// case utils.MetaMongo:
// testDblTpDifDestDir = "dblTpDifInternalMongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, testDblTpDifDest := range testDblTpDifDestTests {
// t.Run(testDblTpDifDestDir, testDblTpDifDest)
// }
// }
func testDblTpDifDestLoadConfig(t *testing.T) {
var err error
testDblTpDifDestPath = path.Join(*dataDir, "conf", "samples", testDblTpDifDestDir)
if testDblTpDifDestCfg, err = config.NewCGRConfigFromPath(testDblTpDifDestPath); err != nil {
t.Error(err)
}
}
// func testDblTpDifDestLoadConfig(t *testing.T) {
// var err error
// testDblTpDifDestPath = path.Join(*dataDir, "conf", "samples", testDblTpDifDestDir)
// if testDblTpDifDestCfg, err = config.NewCGRConfigFromPath(testDblTpDifDestPath); err != nil {
// t.Error(err)
// }
// }
func testDblTpDifDestResetDataDB(t *testing.T) {
if err := engine.InitDataDB(testDblTpDifDestCfg); err != nil {
t.Fatal(err)
}
}
// func testDblTpDifDestResetDataDB(t *testing.T) {
// if err := engine.InitDataDB(testDblTpDifDestCfg); err != nil {
// t.Fatal(err)
// }
// }
func testDblTpDifDestResetStorDb(t *testing.T) {
if err := engine.InitStorDB(testDblTpDifDestCfg); err != nil {
t.Fatal(err)
}
}
// func testDblTpDifDestResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(testDblTpDifDestCfg); err != nil {
// t.Fatal(err)
// }
// }
func testDblTpDifDestStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(testDblTpDifDestPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testDblTpDifDestStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(testDblTpDifDestPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testDblTpDifDestRPCConn(t *testing.T) {
var err error
testDblTpDifDestRPC, err = newRPCClient(testDblTpDifDestCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testDblTpDifDestRPCConn(t *testing.T) {
// var err error
// testDblTpDifDestRPC, err = newRPCClient(testDblTpDifDestCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testDblTpDifDestLoadersLoad(t *testing.T) {
// var reply string
// if err := testDblTpDifDestRPC.Call(context.Background(), utils.LoaderSv1Load,
// &loaders.ArgsProcessFolder{
// LoaderID: "LoaderRatesTest",
// StopOnError: true,
// Caching: utils.StringPointer(utils.MetaReload),
// ForceLock: true,
// }, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned:", reply)
// }
// func testDblTpDifDestLoadersLoad(t *testing.T) {
// // var reply string
// // if err := testDblTpDifDestRPC.Call(context.Background(), utils.LoaderSv1Load,
// // &loaders.ArgsProcessFolder{
// // LoaderID: "LoaderRatesTest",
// // StopOnError: true,
// // Caching: utils.StringPointer(utils.MetaReload),
// // ForceLock: true,
// // }, &reply); err != nil {
// // t.Error(err)
// // } else if reply != utils.OK {
// // t.Error("Unexpected reply returned:", reply)
// // }
}
func testGenerateCsv(t *testing.T) {
filename := "/tmp/dat2"
os.Remove(filename)
f, _ := os.Create(filename)
fmt.Fprintf(f, `#Tenant,ID,FilterIDs,Weights,MinCost,MaxCost,MaxCostStrategy,RateID,RateFilterIDs,RateActivationStart,RateWeights,RateBlocker,RateIntervalStart,RateFixedFee,RateRecurrentFee,RateUnit,RateIncrement`+"\n")
n := 100000
for i := 1; i <= n; i++ {
fmt.Fprintf(f, `cgrates.org,RT_RETAIL%v,,,,,,RT_1,*prefix:~*req.Destination:%v,"* * * * *",,,0s,,0.4,1m,30s`, i, i)
fmt.Fprintf(f, "\n")
fmt.Fprintf(f, `cgrates.org,RT_RETAIL%v,,,,,,RT_1_CHRISTMAS,*prefix:~*req.Destination:%v,* * 24 12 *,;30,false,0s,,0.06,1m,1s`, i, i)
fmt.Fprintf(f, "\n")
}
}
func testDblTpDifDestStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// }
// func testGenerateCsv(t *testing.T) {
// filename := "/tmp/dat2"
// os.Remove(filename)
// f, _ := os.Create(filename)
// fmt.Fprintf(f, `#Tenant,ID,FilterIDs,Weights,MinCost,MaxCost,MaxCostStrategy,RateID,RateFilterIDs,RateActivationStart,RateWeights,RateBlocker,RateIntervalStart,RateFixedFee,RateRecurrentFee,RateUnit,RateIncrement`+"\n")
// n := 100000
// for i := 1; i <= n; i++ {
// fmt.Fprintf(f, `cgrates.org,RT_RETAIL%v,,,,,,RT_1,*prefix:~*req.Destination:%v,"* * * * *",,,0s,,0.4,1m,30s`, i, i)
// fmt.Fprintf(f, "\n")
// fmt.Fprintf(f, `cgrates.org,RT_RETAIL%v,,,,,,RT_1_CHRISTMAS,*prefix:~*req.Destination:%v,* * 24 12 *,;30,false,0s,,0.06,1m,1s`, i, i)
// fmt.Fprintf(f, "\n")
// }
// }
// func testDblTpDifDestStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

572
general_tests/doubleremove_it_test.go
View File

@@ -20,308 +20,308 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"path"
"reflect"
"testing"
"time"
// import (
// "path"
// "reflect"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
// subtests to be executed
var (
doubleRemovePath string
doubleRemoveDIR string
doubleRemove *config.CGRConfig
doubleRemoveAccount = "refundAcc"
doubleRemoveTenant = "cgrates.org"
// // subtests to be executed
// var (
// doubleRemovePath string
// doubleRemoveDIR string
// doubleRemove *config.CGRConfig
// doubleRemoveAccount = "refundAcc"
// doubleRemoveTenant = "cgrates.org"
doubleRemoveIT = []func(t *testing.T){
testdoubleRemoveLoadConfig,
testdoubleRemoveInitDataDb,
testdoubleRemoveStartEngine,
testdoubleRemoveRpcConn,
// doubleRemoveIT = []func(t *testing.T){
// testdoubleRemoveLoadConfig,
// testdoubleRemoveInitDataDb,
// testdoubleRemoveStartEngine,
// testdoubleRemoveRpcConn,
testdoubleRemoveStatQueueProfile,
testdoubleRemoveActions,
testdoubleRemoveActionPlan,
// testdoubleRemoveStatQueueProfile,
// testdoubleRemoveActions,
// testdoubleRemoveActionPlan,
testdoubleRemoveKillEngine,
}
)
// testdoubleRemoveKillEngine,
// }
// )
//Test start here
func TestDoubleRemoveIT(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
doubleRemoveDIR = "tutinternal"
case utils.MetaMySQL:
doubleRemoveDIR = "tutmysql"
case utils.MetaMongo:
doubleRemoveDIR = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
// //Test start here
// func TestDoubleRemoveIT(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// doubleRemoveDIR = "tutinternal"
// case utils.MetaMySQL:
// doubleRemoveDIR = "tutmysql"
// case utils.MetaMongo:
// doubleRemoveDIR = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
for _, stest := range doubleRemoveIT {
t.Run(doubleRemoveDIR, stest)
}
}
// for _, stest := range doubleRemoveIT {
// t.Run(doubleRemoveDIR, stest)
// }
// }
func testdoubleRemoveLoadConfig(t *testing.T) {
var err error
doubleRemovePath = path.Join(*dataDir, "conf", "samples", doubleRemoveDIR)
if doubleRemove, err = config.NewCGRConfigFromPath(doubleRemovePath); err != nil {
t.Error(err)
}
}
// func testdoubleRemoveLoadConfig(t *testing.T) {
// var err error
// doubleRemovePath = path.Join(*dataDir, "conf", "samples", doubleRemoveDIR)
// if doubleRemove, err = config.NewCGRConfigFromPath(doubleRemovePath); err != nil {
// t.Error(err)
// }
// }
func testdoubleRemoveInitDataDb(t *testing.T) {
if err := engine.InitDataDB(doubleRemove); err != nil {
t.Fatal(err)
}
}
// func testdoubleRemoveInitDataDb(t *testing.T) {
// if err := engine.InitDataDB(doubleRemove); err != nil {
// t.Fatal(err)
// }
// }
func testdoubleRemoveStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(doubleRemovePath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testdoubleRemoveStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(doubleRemovePath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testdoubleRemoveRpcConn(t *testing.T) {
var err error
sesRPC, err = newRPCClient(doubleRemove.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal("Could not connect to rater: ", err.Error())
}
}
// func testdoubleRemoveRpcConn(t *testing.T) {
// var err error
// sesRPC, err = newRPCClient(doubleRemove.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal("Could not connect to rater: ", err.Error())
// }
// }
func testdoubleRemoveStatQueueProfile(t *testing.T) {
// check
var reply *engine.StatQueueProfile
if err := sesRPC.Call(utils.AdminSv1GetStatQueueProfile,
&utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &reply); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
// set
statConfig := &engine.StatQueueProfileWithAPIOpts{
StatQueueProfile: &engine.StatQueueProfile{
Tenant: doubleRemoveTenant,
ID: "TEST_PROFILE1",
FilterIDs: []string{"*ai:~*req.AnswerTime:2020-04-18T14:25:00Z|2020-04-18T14:25:00Z"},
QueueLength: 10,
TTL: 10 * time.Second,
Metrics: []*engine.MetricWithFilters{
{
MetricID: "*sum",
},
{
MetricID: "*acd",
},
},
ThresholdIDs: []string{"Val1", "Val2"},
Blocker: true,
Stored: true,
Weight: 20,
MinItems: 1,
},
}
var result string
if err := sesRPC.Call(utils.AdminSv1SetStatQueueProfile, statConfig, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
//check
if err := sesRPC.Call(utils.AdminSv1GetStatQueueProfile,
&utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &reply); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(statConfig.StatQueueProfile, reply) {
t.Errorf("Expecting: %+v, received: %+v", statConfig.StatQueueProfile, reply)
}
// func testdoubleRemoveStatQueueProfile(t *testing.T) {
// // check
// var reply *engine.StatQueueProfile
// if err := sesRPC.Call(utils.AdminSv1GetStatQueueProfile,
// &utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &reply); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// // set
// statConfig := &engine.StatQueueProfileWithAPIOpts{
// StatQueueProfile: &engine.StatQueueProfile{
// Tenant: doubleRemoveTenant,
// ID: "TEST_PROFILE1",
// FilterIDs: []string{"*ai:~*req.AnswerTime:2020-04-18T14:25:00Z|2020-04-18T14:25:00Z"},
// QueueLength: 10,
// TTL: 10 * time.Second,
// Metrics: []*engine.MetricWithFilters{
// {
// MetricID: "*sum",
// },
// {
// MetricID: "*acd",
// },
// },
// ThresholdIDs: []string{"Val1", "Val2"},
// Blocker: true,
// Stored: true,
// Weight: 20,
// MinItems: 1,
// },
// }
// var result string
// if err := sesRPC.Call(utils.AdminSv1SetStatQueueProfile, statConfig, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
// //check
// if err := sesRPC.Call(utils.AdminSv1GetStatQueueProfile,
// &utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &reply); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(statConfig.StatQueueProfile, reply) {
// t.Errorf("Expecting: %+v, received: %+v", statConfig.StatQueueProfile, reply)
// }
//remove
if err := sesRPC.Call(utils.AdminSv1RemoveStatQueueProfile,
&utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
if err := sesRPC.Call(utils.AdminSv1RemoveStatQueueProfile,
&utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &result); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
if err := sesRPC.Call(utils.AdminSv1RemoveStatQueueProfile,
&utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &result); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
// check
if err := sesRPC.Call(utils.AdminSv1GetStatQueueProfile,
&utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &reply); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
// //remove
// if err := sesRPC.Call(utils.AdminSv1RemoveStatQueueProfile,
// &utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
// if err := sesRPC.Call(utils.AdminSv1RemoveStatQueueProfile,
// &utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &result); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// if err := sesRPC.Call(utils.AdminSv1RemoveStatQueueProfile,
// &utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &result); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// // check
// if err := sesRPC.Call(utils.AdminSv1GetStatQueueProfile,
// &utils.TenantID{Tenant: doubleRemoveTenant, ID: "TEST_PROFILE1"}, &reply); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// }
func testdoubleRemoveActions(t *testing.T) {
// check
var reply1 []*utils.TPAction
if doubleRemoveDIR != "tutinternal" { // on internal do not get so we do not cache this action with nil in cache
if err := sesRPC.Call(utils.APIerSv1GetActions, utils.StringPointer("ACTS_1"), &reply1); err == nil || err.Error() != "SERVER_ERROR: NOT_FOUND" {
t.Error(err)
}
}
// set
attrs1 := &v1.V1AttrSetActions{
ActionsId: "ACTS_1",
Actions: []*v1.V1TPAction{
{
Identifier: utils.MetaTopUpReset,
BalanceType: utils.MetaMonetary,
Units: 75.0,
ExpiryTime: utils.MetaUnlimited,
Weight: 20.0}},
}
var reply string
if err := sesRPC.Call(utils.APIerSv1SetActions, &attrs1, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Unexpected reply returned: %s", reply)
}
// set it again (expect EXISTS)
if err := sesRPC.Call(utils.APIerSv1SetActions, &attrs1, &reply); err == nil || err.Error() != "EXISTS" {
t.Error(err)
}
// check
eOut := []*utils.TPAction{
{
Identifier: utils.MetaTopUpReset,
BalanceType: utils.MetaMonetary,
Units: "75",
BalanceWeight: "0",
BalanceBlocker: "false",
BalanceDisabled: "false",
ExpiryTime: utils.MetaUnlimited,
Weight: 20.0,
}}
if err := sesRPC.Call(utils.APIerSv1GetActions, utils.StringPointer("ACTS_1"), &reply1); err != nil {
t.Error("Got error on APIerSv1.GetActions: ", err.Error())
} else if !reflect.DeepEqual(eOut, reply1) {
t.Errorf("Expected: %v, received: %v", utils.ToJSON(eOut), utils.ToJSON(reply1))
}
// remove
if err := sesRPC.Call(utils.APIerSv1RemoveActions, &v1.AttrRemoveActions{
ActionIDs: []string{"ACTS_1"}}, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
// remove it again (expect ErrNotFound)
// if err := sesRPC.Call(utils.APIerSv1RemoveActions, &v1.AttrRemoveActions{
// ActionIDs: []string{"ACTS_1"}}, &reply); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// check again
if err := sesRPC.Call(utils.APIerSv1GetActions, utils.StringPointer("ACTS_1"), &reply1); err == nil || err.Error() != "SERVER_ERROR: NOT_FOUND" {
t.Error(err)
}
}
// func testdoubleRemoveActions(t *testing.T) {
// // check
// var reply1 []*utils.TPAction
// if doubleRemoveDIR != "tutinternal" { // on internal do not get so we do not cache this action with nil in cache
// if err := sesRPC.Call(utils.APIerSv1GetActions, utils.StringPointer("ACTS_1"), &reply1); err == nil || err.Error() != "SERVER_ERROR: NOT_FOUND" {
// t.Error(err)
// }
// }
// // set
// attrs1 := &v1.V1AttrSetActions{
// ActionsId: "ACTS_1",
// Actions: []*v1.V1TPAction{
// {
// Identifier: utils.MetaTopUpReset,
// BalanceType: utils.MetaMonetary,
// Units: 75.0,
// ExpiryTime: utils.MetaUnlimited,
// Weight: 20.0}},
// }
// var reply string
// if err := sesRPC.Call(utils.APIerSv1SetActions, &attrs1, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Unexpected reply returned: %s", reply)
// }
// // set it again (expect EXISTS)
// if err := sesRPC.Call(utils.APIerSv1SetActions, &attrs1, &reply); err == nil || err.Error() != "EXISTS" {
// t.Error(err)
// }
// // check
// eOut := []*utils.TPAction{
// {
// Identifier: utils.MetaTopUpReset,
// BalanceType: utils.MetaMonetary,
// Units: "75",
// BalanceWeight: "0",
// BalanceBlocker: "false",
// BalanceDisabled: "false",
// ExpiryTime: utils.MetaUnlimited,
// Weight: 20.0,
// }}
// if err := sesRPC.Call(utils.APIerSv1GetActions, utils.StringPointer("ACTS_1"), &reply1); err != nil {
// t.Error("Got error on APIerSv1.GetActions: ", err.Error())
// } else if !reflect.DeepEqual(eOut, reply1) {
// t.Errorf("Expected: %v, received: %v", utils.ToJSON(eOut), utils.ToJSON(reply1))
// }
// // remove
// if err := sesRPC.Call(utils.APIerSv1RemoveActions, &v1.AttrRemoveActions{
// ActionIDs: []string{"ACTS_1"}}, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// // remove it again (expect ErrNotFound)
// // if err := sesRPC.Call(utils.APIerSv1RemoveActions, &v1.AttrRemoveActions{
// // ActionIDs: []string{"ACTS_1"}}, &reply); err == nil ||
// // err.Error() != utils.ErrNotFound.Error() {
// // t.Error(err)
// // }
// // check again
// if err := sesRPC.Call(utils.APIerSv1GetActions, utils.StringPointer("ACTS_1"), &reply1); err == nil || err.Error() != "SERVER_ERROR: NOT_FOUND" {
// t.Error(err)
// }
// }
func testdoubleRemoveActionPlan(t *testing.T) {
//set action
var reply string
if err := sesRPC.Call(utils.APIerSv2SetActions, &utils.AttrSetActions{
ActionsId: "ACTS_2",
Actions: []*utils.TPAction{{Identifier: utils.MetaLog}},
}, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
}
// check action
var reply1 []*utils.TPAction
eOut := []*utils.TPAction{
{
Identifier: "*log",
Units: "0",
BalanceWeight: "0",
BalanceBlocker: "false",
BalanceDisabled: "false",
Weight: 0}}
// func testdoubleRemoveActionPlan(t *testing.T) {
// //set action
// var reply string
// if err := sesRPC.Call(utils.APIerSv2SetActions, &utils.AttrSetActions{
// ActionsId: "ACTS_2",
// Actions: []*utils.TPAction{{Identifier: utils.MetaLog}},
// }, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
// }
// // check action
// var reply1 []*utils.TPAction
// eOut := []*utils.TPAction{
// {
// Identifier: "*log",
// Units: "0",
// BalanceWeight: "0",
// BalanceBlocker: "false",
// BalanceDisabled: "false",
// Weight: 0}}
if err := sesRPC.Call(utils.APIerSv1GetActions, utils.StringPointer("ACTS_2"), &reply1); err != nil {
t.Error("Got error on APIerSv1.GetActions: ", err.Error())
} else if !reflect.DeepEqual(eOut, reply1) {
t.Errorf("Expected: %v, received: %v", utils.ToJSON(eOut), utils.ToJSON(reply1))
}
// check ActionPlan
var aps []*engine.ActionPlan
/*
should return ErrNotFound, right now it returns nil and an empty slice,
needs to be reviewed
// if err := sesRPC.Call(utils.APIerSv1GetActions, utils.StringPointer("ACTS_2"), &reply1); err != nil {
// t.Error("Got error on APIerSv1.GetActions: ", err.Error())
// } else if !reflect.DeepEqual(eOut, reply1) {
// t.Errorf("Expected: %v, received: %v", utils.ToJSON(eOut), utils.ToJSON(reply1))
// }
// // check ActionPlan
// var aps []*engine.ActionPlan
// /*
// should return ErrNotFound, right now it returns nil and an empty slice,
// needs to be reviewed
if err := sesRPC.Call(utils.APIerSv1GetActionPlan,
v1.AttrGetActionPlan{ID: utils.EmptyString}, &aps); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("Error: %+v, rcv: %+v", err, utils.ToJSON(aps))
}
*/
// set ActionPlan
atms1 := &v1.AttrSetActionPlan{
Id: "ATMS_1",
ActionPlan: []*v1.AttrActionPlan{
{
ActionsId: "ACTS_2",
Time: utils.MetaASAP,
Weight: 20.0},
},
}
if err := sesRPC.Call(utils.APIerSv1SetActionPlan, &atms1, &reply); err != nil {
t.Error("Got error on APIerSv1.SetActionPlan: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Unexpected reply returned: %s", reply)
}
// set it again (expect EXISTS)
if err := sesRPC.Call(utils.APIerSv1SetActionPlan, &atms1, &reply); err == nil || err.Error() != "EXISTS" {
t.Error(err)
}
// check
if err := sesRPC.Call(utils.APIerSv1GetActionPlan,
&v1.AttrGetActionPlan{ID: "ATMS_1"}, &aps); err != nil {
t.Error(err)
} else if len(aps) != 1 {
t.Errorf("Expected: %v,\n received: %v", 1, len(aps))
} else if aps[0].Id != "ATMS_1" {
// remove
if err := sesRPC.Call(utils.APIerSv1RemoveActionPlan, &v1.AttrGetActionPlan{
ID: "ATMS_1"}, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
//check again
/*
this should return ErrNotFound, right now it returns nil and an empty slice,
needs to be reviewed.
// if err := sesRPC.Call(utils.APIerSv1GetActionPlan,
// v1.AttrGetActionPlan{ID: utils.EmptyString}, &aps); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Errorf("Error: %+v, rcv: %+v", err, utils.ToJSON(aps))
// }
// */
// // set ActionPlan
// atms1 := &v1.AttrSetActionPlan{
// Id: "ATMS_1",
// ActionPlan: []*v1.AttrActionPlan{
// {
// ActionsId: "ACTS_2",
// Time: utils.MetaASAP,
// Weight: 20.0},
// },
// }
// if err := sesRPC.Call(utils.APIerSv1SetActionPlan, &atms1, &reply); err != nil {
// t.Error("Got error on APIerSv1.SetActionPlan: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Unexpected reply returned: %s", reply)
// }
// // set it again (expect EXISTS)
// if err := sesRPC.Call(utils.APIerSv1SetActionPlan, &atms1, &reply); err == nil || err.Error() != "EXISTS" {
// t.Error(err)
// }
// // check
// if err := sesRPC.Call(utils.APIerSv1GetActionPlan,
// &v1.AttrGetActionPlan{ID: "ATMS_1"}, &aps); err != nil {
// t.Error(err)
// } else if len(aps) != 1 {
// t.Errorf("Expected: %v,\n received: %v", 1, len(aps))
// } else if aps[0].Id != "ATMS_1" {
// // remove
// if err := sesRPC.Call(utils.APIerSv1RemoveActionPlan, &v1.AttrGetActionPlan{
// ID: "ATMS_1"}, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// //check again
// /*
// this should return ErrNotFound, right now it returns nil and an empty slice,
// needs to be reviewed.
if err := sesRPC.Call(utils.APIerSv1GetActionPlan,
v1.AttrGetActionPlan{ID: utils.EmptyString}, &aps); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("Error: %+v, rcv: %+v", err, utils.ToJSON(aps))
}
*/
}
}
// if err := sesRPC.Call(utils.APIerSv1GetActionPlan,
// v1.AttrGetActionPlan{ID: utils.EmptyString}, &aps); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Errorf("Error: %+v, rcv: %+v", err, utils.ToJSON(aps))
// }
// */
// }
// }
func testdoubleRemoveKillEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testdoubleRemoveKillEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

1040
general_tests/export_it_test.go
View File

File diff suppressed because it is too large Load Diff

662
general_tests/filter_update_it_test.go
View File

@@ -21,364 +21,364 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"os/exec"
"path"
"reflect"
"testing"
// import (
// "os/exec"
// "path"
// "reflect"
// "testing"
"github.com/cgrates/birpc"
"github.com/cgrates/birpc/context"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/birpc"
// "github.com/cgrates/birpc/context"
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
fltrUpdateCfgPath1, fltrUpdateCfgPath2 string
fltrUpdateCfgDIR1, fltrUpdateCfgDIR2 string
fltrUpdateCfg1, fltrUpdateCfg2 *config.CGRConfig
fltrUpdateRPC1, fltrUpdateRPC2 *birpc.Client
testEng1 *exec.Cmd
sTestsFilterUpdate = []func(t *testing.T){
testFilterUpdateInitCfg,
testFilterUpdateResetDB,
testFilterUpdateStartEngine,
testFilterUpdateRpcConn,
testFilterUpdateSetFilterE1,
testFilterUpdateSetAttrProfileE1,
testFilterUpdateGetAttrProfileForEventEv1E1,
testFilterUpdateGetAttrProfileForEventEv1E2,
testFilterUpdateGetAttrProfileForEventEv2E1NotMatching,
testFilterUpdateGetAttrProfileForEventEv2E2NotMatching,
testFilterUpdateSetFilterAfterAttrE1,
testFilterUpdateGetAttrProfileForEventEv1E1NotMatching,
testFilterUpdateGetAttrProfileForEventEv1E2NotMatching,
testFilterUpdateGetAttrProfileForEventEv2E1,
testFilterUpdateGetAttrProfileForEventEv2E2,
testFilterUpdateStopEngine,
}
ev1 = &utils.CGREvent{
Tenant: "cgrates.org",
ID: "Event1",
Event: map[string]interface{}{
utils.AccountField: "1001",
},
}
ev2 = &utils.CGREvent{
Tenant: "cgrates.org",
ID: "Event2",
Event: map[string]interface{}{
utils.AccountField: "1002",
},
}
)
// var (
// fltrUpdateCfgPath1, fltrUpdateCfgPath2 string
// fltrUpdateCfgDIR1, fltrUpdateCfgDIR2 string
// fltrUpdateCfg1, fltrUpdateCfg2 *config.CGRConfig
// fltrUpdateRPC1, fltrUpdateRPC2 *birpc.Client
// testEng1 *exec.Cmd
// sTestsFilterUpdate = []func(t *testing.T){
// testFilterUpdateInitCfg,
// testFilterUpdateResetDB,
// testFilterUpdateStartEngine,
// testFilterUpdateRpcConn,
// testFilterUpdateSetFilterE1,
// testFilterUpdateSetAttrProfileE1,
// testFilterUpdateGetAttrProfileForEventEv1E1,
// testFilterUpdateGetAttrProfileForEventEv1E2,
// testFilterUpdateGetAttrProfileForEventEv2E1NotMatching,
// testFilterUpdateGetAttrProfileForEventEv2E2NotMatching,
// testFilterUpdateSetFilterAfterAttrE1,
// testFilterUpdateGetAttrProfileForEventEv1E1NotMatching,
// testFilterUpdateGetAttrProfileForEventEv1E2NotMatching,
// testFilterUpdateGetAttrProfileForEventEv2E1,
// testFilterUpdateGetAttrProfileForEventEv2E2,
// testFilterUpdateStopEngine,
// }
// ev1 = &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "Event1",
// Event: map[string]interface{}{
// utils.AccountField: "1001",
// },
// }
// ev2 = &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "Event2",
// Event: map[string]interface{}{
// utils.AccountField: "1002",
// },
// }
// )
func TestFilterUpdateIT(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
t.SkipNow()
case utils.MetaMySQL:
fltrUpdateCfgDIR1 = "fltr_update_e1_mysql"
fltrUpdateCfgDIR2 = "tutmysql"
case utils.MetaMongo:
fltrUpdateCfgDIR1 = "fltr_update_e1_mongo"
fltrUpdateCfgDIR2 = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
// func TestFilterUpdateIT(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// t.SkipNow()
// case utils.MetaMySQL:
// fltrUpdateCfgDIR1 = "fltr_update_e1_mysql"
// fltrUpdateCfgDIR2 = "tutmysql"
// case utils.MetaMongo:
// fltrUpdateCfgDIR1 = "fltr_update_e1_mongo"
// fltrUpdateCfgDIR2 = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
for _, stest1 := range sTestsFilterUpdate {
t.Run(*dbType, stest1)
}
}
// for _, stest1 := range sTestsFilterUpdate {
// t.Run(*dbType, stest1)
// }
// }
//Init Config
func testFilterUpdateInitCfg(t *testing.T) {
var err error
fltrUpdateCfgPath1 = path.Join(*dataDir, "conf", "samples", "cache_replicate", fltrUpdateCfgDIR1)
if fltrUpdateCfg1, err = config.NewCGRConfigFromPath(fltrUpdateCfgPath1); err != nil {
t.Fatal(err)
}
fltrUpdateCfgPath2 = path.Join(*dataDir, "conf", "samples", fltrUpdateCfgDIR2)
if fltrUpdateCfg2, err = config.NewCGRConfigFromPath(fltrUpdateCfgPath2); err != nil {
t.Fatal(err)
}
}
// //Init Config
// func testFilterUpdateInitCfg(t *testing.T) {
// var err error
// fltrUpdateCfgPath1 = path.Join(*dataDir, "conf", "samples", "cache_replicate", fltrUpdateCfgDIR1)
// if fltrUpdateCfg1, err = config.NewCGRConfigFromPath(fltrUpdateCfgPath1); err != nil {
// t.Fatal(err)
// }
// fltrUpdateCfgPath2 = path.Join(*dataDir, "conf", "samples", fltrUpdateCfgDIR2)
// if fltrUpdateCfg2, err = config.NewCGRConfigFromPath(fltrUpdateCfgPath2); err != nil {
// t.Fatal(err)
// }
// }
// Remove data in both rating and accounting db
func testFilterUpdateResetDB(t *testing.T) {
if err := engine.InitDataDB(fltrUpdateCfg1); err != nil {
t.Fatal(err)
}
if err := engine.InitStorDB(fltrUpdateCfg1); err != nil {
t.Fatal(err)
}
}
// // Remove data in both rating and accounting db
// func testFilterUpdateResetDB(t *testing.T) {
// if err := engine.InitDataDB(fltrUpdateCfg1); err != nil {
// t.Fatal(err)
// }
// if err := engine.InitStorDB(fltrUpdateCfg1); err != nil {
// t.Fatal(err)
// }
// }
// Start CGR Engine
func testFilterUpdateStartEngine(t *testing.T) {
var err error
if _, err = engine.StopStartEngine(fltrUpdateCfgPath1, *waitRater); err != nil {
t.Fatal(err)
}
if testEng1, err = engine.StartEngine(fltrUpdateCfgPath2, *waitRater); err != nil {
t.Fatal(err)
}
// // Start CGR Engine
// func testFilterUpdateStartEngine(t *testing.T) {
// var err error
// if _, err = engine.StopStartEngine(fltrUpdateCfgPath1, *waitRater); err != nil {
// t.Fatal(err)
// }
// if testEng1, err = engine.StartEngine(fltrUpdateCfgPath2, *waitRater); err != nil {
// t.Fatal(err)
// }
}
// }
// Connect rpc client to rater
func testFilterUpdateRpcConn(t *testing.T) {
var err error
if fltrUpdateRPC1, err = newRPCClient(fltrUpdateCfg1.ListenCfg()); err != nil {
t.Fatal(err)
}
if fltrUpdateRPC2, err = newRPCClient(fltrUpdateCfg2.ListenCfg()); err != nil {
t.Fatal(err)
}
}
// // Connect rpc client to rater
// func testFilterUpdateRpcConn(t *testing.T) {
// var err error
// if fltrUpdateRPC1, err = newRPCClient(fltrUpdateCfg1.ListenCfg()); err != nil {
// t.Fatal(err)
// }
// if fltrUpdateRPC2, err = newRPCClient(fltrUpdateCfg2.ListenCfg()); err != nil {
// t.Fatal(err)
// }
// }
func testFilterUpdateStopEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testFilterUpdateStopEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }
func testFilterUpdateSetFilterE1(t *testing.T) {
fltr := &engine.FilterWithAPIOpts{
Filter: &engine.Filter{
ID: "FLTR_ID",
Tenant: "cgrates.org",
Rules: []*engine.FilterRule{
{
Type: utils.MetaString,
Element: "~*req.Account",
Values: []string{"1001"},
},
},
},
APIOpts: map[string]interface{}{
utils.CacheOpt: utils.MetaLoad,
},
}
// func testFilterUpdateSetFilterE1(t *testing.T) {
// fltr := &engine.FilterWithAPIOpts{
// Filter: &engine.Filter{
// ID: "FLTR_ID",
// Tenant: "cgrates.org",
// Rules: []*engine.FilterRule{
// {
// Type: utils.MetaString,
// Element: "~*req.Account",
// Values: []string{"1001"},
// },
// },
// },
// APIOpts: map[string]interface{}{
// utils.CacheOpt: utils.MetaLoad,
// },
// }
var reply string
if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1SetFilter, fltr, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
// var reply string
// if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1SetFilter, fltr, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
var result *engine.Filter
if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1GetFilter,
&utils.TenantID{Tenant: "cgrates.org", ID: "FLTR_ID"}, &result); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(fltr.Filter, result) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(fltr.Filter), utils.ToJSON(result))
}
}
// var result *engine.Filter
// if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1GetFilter,
// &utils.TenantID{Tenant: "cgrates.org", ID: "FLTR_ID"}, &result); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(fltr.Filter, result) {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(fltr.Filter), utils.ToJSON(result))
// }
// }
func testFilterUpdateSetAttrProfileE1(t *testing.T) {
attrPrf := &engine.APIAttributeProfileWithAPIOpts{
APIAttributeProfile: &engine.APIAttributeProfile{
FilterIDs: []string{"FLTR_ID"},
ID: "ATTR_ID",
Tenant: "cgrates.org",
Weight: 10,
Attributes: []*engine.ExternalAttribute{
{
Path: "*req.Account",
Value: "1003",
Type: utils.MetaConstant,
},
},
},
APIOpts: map[string]interface{}{
utils.CacheOpt: utils.MetaNone,
},
}
// func testFilterUpdateSetAttrProfileE1(t *testing.T) {
// attrPrf := &engine.APIAttributeProfileWithAPIOpts{
// APIAttributeProfile: &engine.APIAttributeProfile{
// FilterIDs: []string{"FLTR_ID"},
// ID: "ATTR_ID",
// Tenant: "cgrates.org",
// Weight: 10,
// Attributes: []*engine.ExternalAttribute{
// {
// Path: "*req.Account",
// Value: "1003",
// Type: utils.MetaConstant,
// },
// },
// },
// APIOpts: map[string]interface{}{
// utils.CacheOpt: utils.MetaNone,
// },
// }
var reply string
if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1SetAttributeProfile, attrPrf, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
var result *engine.APIAttributeProfile
if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1GetAttributeProfile,
utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "ATTR_ID"}}, &result); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(attrPrf.APIAttributeProfile, result) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(attrPrf.APIAttributeProfile), utils.ToJSON(result))
}
}
// var reply string
// if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1SetAttributeProfile, attrPrf, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
// var result *engine.APIAttributeProfile
// if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1GetAttributeProfile,
// utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "ATTR_ID"}}, &result); err != nil {
// t.Fatal(err)
// }
// if !reflect.DeepEqual(attrPrf.APIAttributeProfile, result) {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(attrPrf.APIAttributeProfile), utils.ToJSON(result))
// }
// }
func testFilterUpdateGetAttrProfileForEventEv1E1(t *testing.T) {
eAttrPrf := &engine.APIAttributeProfile{
Tenant: "cgrates.org",
FilterIDs: []string{"FLTR_ID"},
ID: "ATTR_ID",
Weight: 10,
Attributes: []*engine.ExternalAttribute{
{
Path: "*req.Account",
Value: "1003",
Type: utils.MetaConstant,
},
},
}
// func testFilterUpdateGetAttrProfileForEventEv1E1(t *testing.T) {
// eAttrPrf := &engine.APIAttributeProfile{
// Tenant: "cgrates.org",
// FilterIDs: []string{"FLTR_ID"},
// ID: "ATTR_ID",
// Weight: 10,
// Attributes: []*engine.ExternalAttribute{
// {
// Path: "*req.Account",
// Value: "1003",
// Type: utils.MetaConstant,
// },
// },
// }
var attrReply *engine.APIAttributeProfile
if err := fltrUpdateRPC1.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
ev1, &attrReply); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(eAttrPrf, attrReply) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(eAttrPrf), utils.ToJSON(attrReply))
}
}
// var attrReply *engine.APIAttributeProfile
// if err := fltrUpdateRPC1.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
// ev1, &attrReply); err != nil {
// t.Fatal(err)
// }
// if !reflect.DeepEqual(eAttrPrf, attrReply) {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(eAttrPrf), utils.ToJSON(attrReply))
// }
// }
func testFilterUpdateGetAttrProfileForEventEv1E2(t *testing.T) {
eAttrPrf := &engine.APIAttributeProfile{
Tenant: "cgrates.org",
FilterIDs: []string{"FLTR_ID"},
ID: "ATTR_ID",
Weight: 10,
Attributes: []*engine.ExternalAttribute{
{
Path: "*req.Account",
Value: "1003",
Type: utils.MetaConstant,
},
},
}
// func testFilterUpdateGetAttrProfileForEventEv1E2(t *testing.T) {
// eAttrPrf := &engine.APIAttributeProfile{
// Tenant: "cgrates.org",
// FilterIDs: []string{"FLTR_ID"},
// ID: "ATTR_ID",
// Weight: 10,
// Attributes: []*engine.ExternalAttribute{
// {
// Path: "*req.Account",
// Value: "1003",
// Type: utils.MetaConstant,
// },
// },
// }
var attrReply *engine.APIAttributeProfile
if err := fltrUpdateRPC2.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
ev1, &attrReply); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(eAttrPrf, attrReply) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(eAttrPrf), utils.ToJSON(attrReply))
}
}
// var attrReply *engine.APIAttributeProfile
// if err := fltrUpdateRPC2.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
// ev1, &attrReply); err != nil {
// t.Fatal(err)
// }
// if !reflect.DeepEqual(eAttrPrf, attrReply) {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(eAttrPrf), utils.ToJSON(attrReply))
// }
// }
func testFilterUpdateGetAttrProfileForEventEv2E1(t *testing.T) {
eAttrPrf := &engine.APIAttributeProfile{
Tenant: "cgrates.org",
FilterIDs: []string{"FLTR_ID"},
ID: "ATTR_ID",
Weight: 10,
Attributes: []*engine.ExternalAttribute{
{
Path: "*req.Account",
Value: "1003",
Type: utils.MetaConstant,
},
},
}
// func testFilterUpdateGetAttrProfileForEventEv2E1(t *testing.T) {
// eAttrPrf := &engine.APIAttributeProfile{
// Tenant: "cgrates.org",
// FilterIDs: []string{"FLTR_ID"},
// ID: "ATTR_ID",
// Weight: 10,
// Attributes: []*engine.ExternalAttribute{
// {
// Path: "*req.Account",
// Value: "1003",
// Type: utils.MetaConstant,
// },
// },
// }
var attrReply *engine.APIAttributeProfile
if err := fltrUpdateRPC1.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
ev2, &attrReply); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(eAttrPrf, attrReply) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(eAttrPrf), utils.ToJSON(attrReply))
}
}
// var attrReply *engine.APIAttributeProfile
// if err := fltrUpdateRPC1.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
// ev2, &attrReply); err != nil {
// t.Fatal(err)
// }
// if !reflect.DeepEqual(eAttrPrf, attrReply) {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(eAttrPrf), utils.ToJSON(attrReply))
// }
// }
func testFilterUpdateGetAttrProfileForEventEv2E2(t *testing.T) {
eAttrPrf := &engine.APIAttributeProfile{
Tenant: "cgrates.org",
FilterIDs: []string{"FLTR_ID"},
ID: "ATTR_ID",
Weight: 10,
Attributes: []*engine.ExternalAttribute{
{
Path: "*req.Account",
Value: "1003",
Type: utils.MetaConstant,
},
},
}
// func testFilterUpdateGetAttrProfileForEventEv2E2(t *testing.T) {
// eAttrPrf := &engine.APIAttributeProfile{
// Tenant: "cgrates.org",
// FilterIDs: []string{"FLTR_ID"},
// ID: "ATTR_ID",
// Weight: 10,
// Attributes: []*engine.ExternalAttribute{
// {
// Path: "*req.Account",
// Value: "1003",
// Type: utils.MetaConstant,
// },
// },
// }
var attrReply *engine.APIAttributeProfile
if err := fltrUpdateRPC2.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
ev2, &attrReply); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(eAttrPrf, attrReply) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(eAttrPrf), utils.ToJSON(attrReply))
}
}
// var attrReply *engine.APIAttributeProfile
// if err := fltrUpdateRPC2.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
// ev2, &attrReply); err != nil {
// t.Fatal(err)
// }
// if !reflect.DeepEqual(eAttrPrf, attrReply) {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(eAttrPrf), utils.ToJSON(attrReply))
// }
// }
func testFilterUpdateSetFilterAfterAttrE1(t *testing.T) {
fltr := &engine.FilterWithAPIOpts{
Filter: &engine.Filter{
ID: "FLTR_ID",
Tenant: "cgrates.org",
Rules: []*engine.FilterRule{
{
Type: utils.MetaString,
Element: "~*req.Account",
Values: []string{"1002"},
},
},
},
APIOpts: map[string]interface{}{
utils.CacheOpt: utils.MetaLoad,
},
}
// func testFilterUpdateSetFilterAfterAttrE1(t *testing.T) {
// fltr := &engine.FilterWithAPIOpts{
// Filter: &engine.Filter{
// ID: "FLTR_ID",
// Tenant: "cgrates.org",
// Rules: []*engine.FilterRule{
// {
// Type: utils.MetaString,
// Element: "~*req.Account",
// Values: []string{"1002"},
// },
// },
// },
// APIOpts: map[string]interface{}{
// utils.CacheOpt: utils.MetaLoad,
// },
// }
var reply string
if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1SetFilter, fltr, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Unexpected reply returned", reply)
}
// var reply string
// if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1SetFilter, fltr, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error("Unexpected reply returned", reply)
// }
var result *engine.Filter
if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1GetFilter,
&utils.TenantID{Tenant: "cgrates.org", ID: "FLTR_ID"}, &result); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(fltr.Filter, result) {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(fltr.Filter), utils.ToJSON(result))
}
}
// var result *engine.Filter
// if err := fltrUpdateRPC1.Call(context.Background(), utils.AdminSv1GetFilter,
// &utils.TenantID{Tenant: "cgrates.org", ID: "FLTR_ID"}, &result); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(fltr.Filter, result) {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ToJSON(fltr.Filter), utils.ToJSON(result))
// }
// }
func testFilterUpdateGetAttrProfileForEventEv1E1NotMatching(t *testing.T) {
var attrReply *engine.APIAttributeProfile
if err := fltrUpdateRPC1.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
ev1, &attrReply); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
}
}
// func testFilterUpdateGetAttrProfileForEventEv1E1NotMatching(t *testing.T) {
// var attrReply *engine.APIAttributeProfile
// if err := fltrUpdateRPC1.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
// ev1, &attrReply); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
// }
// }
func testFilterUpdateGetAttrProfileForEventEv1E2NotMatching(t *testing.T) {
var attrReply *engine.APIAttributeProfile
if err := fltrUpdateRPC2.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
ev1, &attrReply); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
}
}
// func testFilterUpdateGetAttrProfileForEventEv1E2NotMatching(t *testing.T) {
// var attrReply *engine.APIAttributeProfile
// if err := fltrUpdateRPC2.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
// ev1, &attrReply); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
// }
// }
func testFilterUpdateGetAttrProfileForEventEv2E1NotMatching(t *testing.T) {
var attrReply *engine.APIAttributeProfile
if err := fltrUpdateRPC1.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
ev2, &attrReply); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
}
}
// func testFilterUpdateGetAttrProfileForEventEv2E1NotMatching(t *testing.T) {
// var attrReply *engine.APIAttributeProfile
// if err := fltrUpdateRPC1.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
// ev2, &attrReply); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
// }
// }
func testFilterUpdateGetAttrProfileForEventEv2E2NotMatching(t *testing.T) {
var attrReply *engine.APIAttributeProfile
if err := fltrUpdateRPC2.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
ev2, &attrReply); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
}
}
// func testFilterUpdateGetAttrProfileForEventEv2E2NotMatching(t *testing.T) {
// var attrReply *engine.APIAttributeProfile
// if err := fltrUpdateRPC2.Call(context.Background(), utils.AttributeSv1GetAttributeForEvent,
// ev2, &attrReply); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
// }
// }

3832
general_tests/filtered_replication_it_test.go
View File

File diff suppressed because it is too large Load Diff

2060
general_tests/filters_it_test.go
View File

File diff suppressed because it is too large Load Diff

1060
general_tests/gocs_it_test.go
View File

File diff suppressed because it is too large Load Diff

38
general_tests/ld_process_match_ac_it_test.go
View File

@@ -41,11 +41,11 @@ var (
testLdPrMatchAcLoadConfig,
testLdPrMatchAcResetDataDB,
testLdPrMatchAcResetStorDb,
testLdPrMatchAcStartEngine,
// testLdPrMatchAcStartEngine,
testLdPrMatchAcRPCConn,
testLdPrMatchAcLoadTP,
testLdPrMatchAcCDRSProcessEvent,
testLdPrMatchAcStopCgrEngine,
// testLdPrMatchAcStopCgrEngine,
}
)
@@ -115,24 +115,22 @@ func testLdPrMatchAcLoadTP(t *testing.T) {
}
func testLdPrMatchAcCDRSProcessEvent(t *testing.T) {
ev := &engine.ArgV1ProcessEvent{
CGREvent: utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestEv1",
Event: map[string]interface{}{
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestEv1",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1001",
utils.Subject: "1001",
utils.Destination: "1002",
utils.Usage: time.Minute,
},
APIOpts: map[string]interface{}{
utils.OptsRateS: false,
utils.OptsCDRsExport: false,
utils.OptsAccountS: true,
},
ev := &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestEv1",
Event: map[string]interface{}{
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestEv1",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1001",
utils.Subject: "1001",
utils.Destination: "1002",
utils.Usage: time.Minute,
},
APIOpts: map[string]interface{}{
utils.OptsRateS: false,
utils.OptsCDRsExport: false,
utils.OptsAccountS: true,
},
}
var rply string

2
general_tests/ld_process_match_rt_it_test.go
View File

@@ -15,7 +15,7 @@ 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 <http://www.gnu.org/licenses/>
*/
package apis
package general_tests
import (
"net"

598
general_tests/poster_it_test.go
View File

@@ -20,322 +20,322 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"encoding/json"
"fmt"
"net/rpc"
"os"
"path"
"testing"
"time"
// import (
// "encoding/json"
// "fmt"
// "net/rpc"
// "os"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/ees"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/ees"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
pstrCfg *config.CGRConfig
pstrRpc *rpc.Client
pstrCfgPath string
pstrConfigDIR string
// var (
// pstrCfg *config.CGRConfig
// pstrRpc *rpc.Client
// pstrCfgPath string
// pstrConfigDIR string
sTestsPosterIT = []func(t *testing.T){
testPosterITInitCfg,
testPosterITInitCdrDb,
testPosterITStartEngine,
testPosterITRpcConn,
testPosterITSetAccount,
// sTestsPosterIT = []func(t *testing.T){
// testPosterITInitCfg,
// testPosterITInitCdrDb,
// testPosterITStartEngine,
// testPosterITRpcConn,
// testPosterITSetAccount,
testPosterITAMQP,
testPosterITAMQPv1,
testPosterITSQS,
testPosterITS3,
testPosterITKafka,
// testPosterITAMQP,
// testPosterITAMQPv1,
// testPosterITSQS,
// testPosterITS3,
// testPosterITKafka,
testPosterITStopCgrEngine,
}
pstrAccount = &utils.AttrSetAccount{Tenant: "cgrates.org", Account: "dan2904"}
)
// testPosterITStopCgrEngine,
// }
// pstrAccount = &utils.AttrSetAccount{Tenant: "cgrates.org", Account: "dan2904"}
// )
func TestPosterIT(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
pstrConfigDIR = "actions_internal"
case utils.MetaMySQL:
pstrConfigDIR = "actions_mysql"
case utils.MetaMongo:
pstrConfigDIR = "actions_mongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
if *encoding == utils.MetaGOB {
pstrConfigDIR += "_gob"
}
// func TestPosterIT(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// pstrConfigDIR = "actions_internal"
// case utils.MetaMySQL:
// pstrConfigDIR = "actions_mysql"
// case utils.MetaMongo:
// pstrConfigDIR = "actions_mongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// if *encoding == utils.MetaGOB {
// pstrConfigDIR += "_gob"
// }
for _, stest := range sTestsPosterIT {
t.Run(pstrConfigDIR, stest)
}
}
// for _, stest := range sTestsPosterIT {
// t.Run(pstrConfigDIR, stest)
// }
// }
func testPosterITInitCfg(t *testing.T) {
pstrCfgPath = path.Join(*dataDir, "conf", "samples", pstrConfigDIR)
var err error
pstrCfg, err = config.NewCGRConfigFromPath(pstrCfgPath)
if err != nil {
t.Error(err)
}
}
// func testPosterITInitCfg(t *testing.T) {
// pstrCfgPath = path.Join(*dataDir, "conf", "samples", pstrConfigDIR)
// var err error
// pstrCfg, err = config.NewCGRConfigFromPath(pstrCfgPath)
// if err != nil {
// t.Error(err)
// }
// }
func testPosterITInitCdrDb(t *testing.T) {
if err := engine.InitDataDB(pstrCfg); err != nil { // need it for versions
t.Fatal(err)
}
if err := engine.InitStorDB(pstrCfg); err != nil {
t.Fatal(err)
}
}
// func testPosterITInitCdrDb(t *testing.T) {
// if err := engine.InitDataDB(pstrCfg); err != nil { // need it for versions
// t.Fatal(err)
// }
// if err := engine.InitStorDB(pstrCfg); err != nil {
// t.Fatal(err)
// }
// }
func testPosterITStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(pstrCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testPosterITStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(pstrCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testPosterITRpcConn(t *testing.T) {
var err error
pstrRpc, err = newRPCClient(pstrCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal(err)
}
}
// func testPosterITRpcConn(t *testing.T) {
// var err error
// pstrRpc, err = newRPCClient(pstrCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal(err)
// }
// }
func testPosterReadFolder(format string) (expEv *ees.ExportEvents, err error) {
filesInDir, _ := os.ReadDir(pstrCfg.GeneralCfg().FailedPostsDir)
if len(filesInDir) == 0 {
err = fmt.Errorf("No files in directory: %s", pstrCfg.GeneralCfg().FailedPostsDir)
return
}
for _, file := range filesInDir { // First file in directory is the one we need, harder to find it's name out of config
fileName := file.Name()
filePath := path.Join(pstrCfg.GeneralCfg().FailedPostsDir, fileName)
// func testPosterReadFolder(format string) (expEv *ees.ExportEvents, err error) {
// filesInDir, _ := os.ReadDir(pstrCfg.GeneralCfg().FailedPostsDir)
// if len(filesInDir) == 0 {
// err = fmt.Errorf("No files in directory: %s", pstrCfg.GeneralCfg().FailedPostsDir)
// return
// }
// for _, file := range filesInDir { // First file in directory is the one we need, harder to find it's name out of config
// fileName := file.Name()
// filePath := path.Join(pstrCfg.GeneralCfg().FailedPostsDir, fileName)
expEv, err = ees.NewExportEventsFromFile(filePath)
if err != nil {
return
}
if expEv.Format == format {
return
}
}
err = fmt.Errorf("Format not found")
return
}
// expEv, err = ees.NewExportEventsFromFile(filePath)
// if err != nil {
// return
// }
// if expEv.Format == format {
// return
// }
// }
// err = fmt.Errorf("Format not found")
// return
// }
func testPosterITSetAccount(t *testing.T) {
var reply string
if err := pstrRpc.Call(utils.APIerSv1SetAccount, pstrAccount, &reply); err != nil {
t.Error("Got error on APIerSv1.SetAccount: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv1.SetAccount received: %s", reply)
}
}
// func testPosterITSetAccount(t *testing.T) {
// var reply string
// if err := pstrRpc.Call(utils.APIerSv1SetAccount, pstrAccount, &reply); err != nil {
// t.Error("Got error on APIerSv1.SetAccount: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv1.SetAccount received: %s", reply)
// }
// }
func testPosterITAMQP(t *testing.T) {
var reply string
attrsAA := &utils.AttrSetActions{
ActionsId: "ACT_AMQP",
Actions: []*utils.TPAction{ // set a action with a wrong endpoint to easily check if it was executed
{Identifier: utils.MetaExport, ExtraParameters: "amqp_fail"},
},
}
if err := pstrRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
t.Error("Got error on APIerSv2.SetActions: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
}
attrsEA := &utils.AttrExecuteAction{Tenant: pstrAccount.Tenant, Account: pstrAccount.Account, ActionsId: attrsAA.ActionsId}
if err := pstrRpc.Call(utils.APIerSv1ExecuteAction, attrsEA, &reply); err != nil {
t.Error("Got error on APIerSv1.ExecuteAction: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv1.ExecuteAction received: %s", reply)
}
// verify if acction was executed
time.Sleep(100 * time.Millisecond)
ev, err := testPosterReadFolder(utils.MetaAMQPjsonMap)
if err != nil {
t.Fatal(err)
}
if len(ev.Events) != 1 {
t.Fatalf("Expected 1 event received: %d events", len(ev.Events))
}
body := ev.Events[0].([]byte)
var acc map[string]interface{}
if err := json.Unmarshal(body, &acc); err != nil {
t.Fatal(err)
}
if acc[utils.AccountField] != utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account) {
t.Errorf("Expected %q ,received %q", utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account), acc[utils.AccountField])
}
}
// func testPosterITAMQP(t *testing.T) {
// var reply string
// attrsAA := &utils.AttrSetActions{
// ActionsId: "ACT_AMQP",
// Actions: []*utils.TPAction{ // set a action with a wrong endpoint to easily check if it was executed
// {Identifier: utils.MetaExport, ExtraParameters: "amqp_fail"},
// },
// }
// if err := pstrRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
// t.Error("Got error on APIerSv2.SetActions: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
// }
// attrsEA := &utils.AttrExecuteAction{Tenant: pstrAccount.Tenant, Account: pstrAccount.Account, ActionsId: attrsAA.ActionsId}
// if err := pstrRpc.Call(utils.APIerSv1ExecuteAction, attrsEA, &reply); err != nil {
// t.Error("Got error on APIerSv1.ExecuteAction: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv1.ExecuteAction received: %s", reply)
// }
// // verify if acction was executed
// time.Sleep(100 * time.Millisecond)
// ev, err := testPosterReadFolder(utils.MetaAMQPjsonMap)
// if err != nil {
// t.Fatal(err)
// }
// if len(ev.Events) != 1 {
// t.Fatalf("Expected 1 event received: %d events", len(ev.Events))
// }
// body := ev.Events[0].([]byte)
// var acc map[string]interface{}
// if err := json.Unmarshal(body, &acc); err != nil {
// t.Fatal(err)
// }
// if acc[utils.AccountField] != utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account) {
// t.Errorf("Expected %q ,received %q", utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account), acc[utils.AccountField])
// }
// }
func testPosterITAMQPv1(t *testing.T) {
var reply string
attrsAA := &utils.AttrSetActions{
ActionsId: "ACT_AMQPv1",
Actions: []*utils.TPAction{ // set a action with a wrong endpoint to easily check if it was executed
{Identifier: utils.MetaExport, ExtraParameters: "aws_fail"},
},
}
if err := pstrRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
t.Error("Got error on APIerSv2.SetActions: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
}
attrsEA := &utils.AttrExecuteAction{Tenant: pstrAccount.Tenant, Account: pstrAccount.Account, ActionsId: attrsAA.ActionsId}
if err := pstrRpc.Call(utils.APIerSv1ExecuteAction, attrsEA, &reply); err != nil {
t.Error("Got error on APIerSv1.ExecuteAction: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv1.ExecuteAction received: %s", reply)
}
// verify if acction was executed
time.Sleep(150 * time.Millisecond)
ev, err := testPosterReadFolder(utils.MetaAMQPV1jsonMap)
if err != nil {
t.Fatal(err)
}
if len(ev.Events) != 1 {
t.Fatalf("Expected 1 event received: %d events", len(ev.Events))
}
body := ev.Events[0].([]byte)
var acc map[string]interface{}
if err := json.Unmarshal(body, &acc); err != nil {
t.Fatal(err)
}
if acc[utils.AccountField] != utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account) {
t.Errorf("Expected %q ,received %q", utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account), acc[utils.AccountField])
}
}
// func testPosterITAMQPv1(t *testing.T) {
// var reply string
// attrsAA := &utils.AttrSetActions{
// ActionsId: "ACT_AMQPv1",
// Actions: []*utils.TPAction{ // set a action with a wrong endpoint to easily check if it was executed
// {Identifier: utils.MetaExport, ExtraParameters: "aws_fail"},
// },
// }
// if err := pstrRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
// t.Error("Got error on APIerSv2.SetActions: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
// }
// attrsEA := &utils.AttrExecuteAction{Tenant: pstrAccount.Tenant, Account: pstrAccount.Account, ActionsId: attrsAA.ActionsId}
// if err := pstrRpc.Call(utils.APIerSv1ExecuteAction, attrsEA, &reply); err != nil {
// t.Error("Got error on APIerSv1.ExecuteAction: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv1.ExecuteAction received: %s", reply)
// }
// // verify if acction was executed
// time.Sleep(150 * time.Millisecond)
// ev, err := testPosterReadFolder(utils.MetaAMQPV1jsonMap)
// if err != nil {
// t.Fatal(err)
// }
// if len(ev.Events) != 1 {
// t.Fatalf("Expected 1 event received: %d events", len(ev.Events))
// }
// body := ev.Events[0].([]byte)
// var acc map[string]interface{}
// if err := json.Unmarshal(body, &acc); err != nil {
// t.Fatal(err)
// }
// if acc[utils.AccountField] != utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account) {
// t.Errorf("Expected %q ,received %q", utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account), acc[utils.AccountField])
// }
// }
func testPosterITSQS(t *testing.T) {
var reply string
attrsAA := &utils.AttrSetActions{
ActionsId: "ACT_SQS",
Actions: []*utils.TPAction{ // set a action with a wrong endpoint to easily check if it was executed
{Identifier: utils.MetaExport, ExtraParameters: "sqs_fail"},
},
}
if err := pstrRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
t.Error("Got error on APIerSv2.SetActions: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
}
attrsEA := &utils.AttrExecuteAction{Tenant: pstrAccount.Tenant, Account: pstrAccount.Account, ActionsId: attrsAA.ActionsId}
if err := pstrRpc.Call(utils.APIerSv1ExecuteAction, attrsEA, &reply); err != nil {
t.Error("Got error on APIerSv1.ExecuteAction: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv1.ExecuteAction received: %s", reply)
}
// verify if acction was executed
time.Sleep(100 * time.Millisecond)
ev, err := testPosterReadFolder(utils.MetaSQSjsonMap)
if err != nil {
t.Fatal(err)
}
if len(ev.Events) != 1 {
t.Fatalf("Expected 1 event received: %d events", len(ev.Events))
}
body := ev.Events[0].([]byte)
var acc map[string]interface{}
if err := json.Unmarshal(body, &acc); err != nil {
t.Fatal(err)
}
if acc[utils.AccountField] != utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account) {
t.Errorf("Expected %q ,received %q", utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account), acc[utils.AccountField])
}
}
// func testPosterITSQS(t *testing.T) {
// var reply string
// attrsAA := &utils.AttrSetActions{
// ActionsId: "ACT_SQS",
// Actions: []*utils.TPAction{ // set a action with a wrong endpoint to easily check if it was executed
// {Identifier: utils.MetaExport, ExtraParameters: "sqs_fail"},
// },
// }
// if err := pstrRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
// t.Error("Got error on APIerSv2.SetActions: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
// }
// attrsEA := &utils.AttrExecuteAction{Tenant: pstrAccount.Tenant, Account: pstrAccount.Account, ActionsId: attrsAA.ActionsId}
// if err := pstrRpc.Call(utils.APIerSv1ExecuteAction, attrsEA, &reply); err != nil {
// t.Error("Got error on APIerSv1.ExecuteAction: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv1.ExecuteAction received: %s", reply)
// }
// // verify if acction was executed
// time.Sleep(100 * time.Millisecond)
// ev, err := testPosterReadFolder(utils.MetaSQSjsonMap)
// if err != nil {
// t.Fatal(err)
// }
// if len(ev.Events) != 1 {
// t.Fatalf("Expected 1 event received: %d events", len(ev.Events))
// }
// body := ev.Events[0].([]byte)
// var acc map[string]interface{}
// if err := json.Unmarshal(body, &acc); err != nil {
// t.Fatal(err)
// }
// if acc[utils.AccountField] != utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account) {
// t.Errorf("Expected %q ,received %q", utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account), acc[utils.AccountField])
// }
// }
func testPosterITS3(t *testing.T) {
var reply string
attrsAA := &utils.AttrSetActions{
ActionsId: "ACT_S3",
Actions: []*utils.TPAction{ // set a action with a wrong endpoint to easily check if it was executed
{Identifier: utils.MetaExport, ExtraParameters: "s3_fail"},
},
}
if err := pstrRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
t.Error("Got error on APIerSv2.SetActions: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
}
attrsEA := &utils.AttrExecuteAction{Tenant: pstrAccount.Tenant, Account: pstrAccount.Account, ActionsId: attrsAA.ActionsId}
if err := pstrRpc.Call(utils.APIerSv1ExecuteAction, attrsEA, &reply); err != nil {
t.Error("Got error on APIerSv1.ExecuteAction: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv1.ExecuteAction received: %s", reply)
}
// verify if acction was executed
time.Sleep(100 * time.Millisecond)
ev, err := testPosterReadFolder(utils.MetaS3jsonMap)
if err != nil {
t.Fatal(err)
}
if len(ev.Events) != 1 {
t.Fatalf("Expected 1 event received: %d events", len(ev.Events))
}
body := ev.Events[0].([]byte)
var acc map[string]interface{}
if err := json.Unmarshal(body, &acc); err != nil {
t.Fatal(err)
}
if acc[utils.AccountField] != utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account) {
t.Errorf("Expected %q ,received %q", utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account), acc[utils.AccountField])
}
}
// func testPosterITS3(t *testing.T) {
// var reply string
// attrsAA := &utils.AttrSetActions{
// ActionsId: "ACT_S3",
// Actions: []*utils.TPAction{ // set a action with a wrong endpoint to easily check if it was executed
// {Identifier: utils.MetaExport, ExtraParameters: "s3_fail"},
// },
// }
// if err := pstrRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
// t.Error("Got error on APIerSv2.SetActions: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
// }
// attrsEA := &utils.AttrExecuteAction{Tenant: pstrAccount.Tenant, Account: pstrAccount.Account, ActionsId: attrsAA.ActionsId}
// if err := pstrRpc.Call(utils.APIerSv1ExecuteAction, attrsEA, &reply); err != nil {
// t.Error("Got error on APIerSv1.ExecuteAction: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv1.ExecuteAction received: %s", reply)
// }
// // verify if acction was executed
// time.Sleep(100 * time.Millisecond)
// ev, err := testPosterReadFolder(utils.MetaS3jsonMap)
// if err != nil {
// t.Fatal(err)
// }
// if len(ev.Events) != 1 {
// t.Fatalf("Expected 1 event received: %d events", len(ev.Events))
// }
// body := ev.Events[0].([]byte)
// var acc map[string]interface{}
// if err := json.Unmarshal(body, &acc); err != nil {
// t.Fatal(err)
// }
// if acc[utils.AccountField] != utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account) {
// t.Errorf("Expected %q ,received %q", utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account), acc[utils.AccountField])
// }
// }
func testPosterITKafka(t *testing.T) {
var reply string
attrsAA := &utils.AttrSetActions{
ActionsId: "ACT_Kafka",
Actions: []*utils.TPAction{ // set a action with a wrong endpoint to easily check if it was executed
{Identifier: utils.MetaExport, ExtraParameters: "kafka_fail"},
},
}
if err := pstrRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
t.Error("Got error on APIerSv2.SetActions: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
}
attrsEA := &utils.AttrExecuteAction{Tenant: pstrAccount.Tenant, Account: pstrAccount.Account, ActionsId: attrsAA.ActionsId}
if err := pstrRpc.Call(utils.APIerSv1ExecuteAction, attrsEA, &reply); err != nil {
t.Error("Got error on APIerSv1.ExecuteAction: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv1.ExecuteAction received: %s", reply)
}
// verify if acction was executed
time.Sleep(500 * time.Millisecond)
ev, err := testPosterReadFolder(utils.MetaKafkajsonMap)
if err != nil {
t.Fatal(err)
}
if len(ev.Events) != 1 {
t.Fatalf("Expected 1 event received: %d events", len(ev.Events))
}
body := ev.Events[0].([]byte)
var acc map[string]interface{}
if err := json.Unmarshal(body, &acc); err != nil {
t.Fatal(err)
}
if acc[utils.AccountField] != utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account) {
t.Errorf("Expected %q ,received %q", utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account), acc[utils.AccountField])
}
}
// func testPosterITKafka(t *testing.T) {
// var reply string
// attrsAA := &utils.AttrSetActions{
// ActionsId: "ACT_Kafka",
// Actions: []*utils.TPAction{ // set a action with a wrong endpoint to easily check if it was executed
// {Identifier: utils.MetaExport, ExtraParameters: "kafka_fail"},
// },
// }
// if err := pstrRpc.Call(utils.APIerSv2SetActions, attrsAA, &reply); err != nil && err.Error() != utils.ErrExists.Error() {
// t.Error("Got error on APIerSv2.SetActions: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.SetActions received: %s", reply)
// }
// attrsEA := &utils.AttrExecuteAction{Tenant: pstrAccount.Tenant, Account: pstrAccount.Account, ActionsId: attrsAA.ActionsId}
// if err := pstrRpc.Call(utils.APIerSv1ExecuteAction, attrsEA, &reply); err != nil {
// t.Error("Got error on APIerSv1.ExecuteAction: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv1.ExecuteAction received: %s", reply)
// }
// // verify if acction was executed
// time.Sleep(500 * time.Millisecond)
// ev, err := testPosterReadFolder(utils.MetaKafkajsonMap)
// if err != nil {
// t.Fatal(err)
// }
// if len(ev.Events) != 1 {
// t.Fatalf("Expected 1 event received: %d events", len(ev.Events))
// }
// body := ev.Events[0].([]byte)
// var acc map[string]interface{}
// if err := json.Unmarshal(body, &acc); err != nil {
// t.Fatal(err)
// }
// if acc[utils.AccountField] != utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account) {
// t.Errorf("Expected %q ,received %q", utils.ConcatenatedKey(pstrAccount.Tenant, pstrAccount.Account), acc[utils.AccountField])
// }
// }
func testPosterITStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(*waitRater); err != nil {
t.Error(err)
}
}
// func testPosterITStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(*waitRater); err != nil {
// t.Error(err)
// }
// }

554
general_tests/redis_cluster_it_test.go
View File

@@ -21,303 +21,303 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"bytes"
"flag"
"fmt"
"net/rpc"
"os"
"os/exec"
"path"
"reflect"
"testing"
"time"
// import (
// "bytes"
// "flag"
// "fmt"
// "net/rpc"
// "os"
// "os/exec"
// "path"
// "reflect"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
/*
* Documentation:
* This code should work on redis 5 or later:
* `redis-cli --cluster create 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 127.0.0.1:7006 --cluster-replicas 1`
* For redis 4 or before you need to create create the cluster manualy:
* - install ruby
* - install redis gem: `gem install redis`
* - download the `redis-trib.rb` from the source code
* - start the 6 nodes with the command `redis-server node1.conf`
* - configure the cluster with the following command:
* `./redis-trib.rb create --replicas 1 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 127.0.0.1:7006`
*
* To run the tests you need to specify the `redisCluster` flag and have the redis stopped:
* `go test github.com/cgrates/cgrates/general_tests -tags=integration -dbtype=*mysql -run=TestRedisCluster -redisCluster -v`
*
* The configuration of the cluster is the following:
* - node1 127.0.0.1:7001 master
* - node2 127.0.0.1:7002 master
* - node3 127.0.0.1:7003 master
* - node4 127.0.0.1:7004 replica
* - node5 127.0.0.1:7005 replica
* - node6 127.0.0.1:7006 replica
* The replicas do not allways select the same master
*/
// /*
// * Documentation:
// * This code should work on redis 5 or later:
// * `redis-cli --cluster create 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 127.0.0.1:7006 --cluster-replicas 1`
// * For redis 4 or before you need to create create the cluster manualy:
// * - install ruby
// * - install redis gem: `gem install redis`
// * - download the `redis-trib.rb` from the source code
// * - start the 6 nodes with the command `redis-server node1.conf`
// * - configure the cluster with the following command:
// * `./redis-trib.rb create --replicas 1 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 127.0.0.1:7006`
// *
// * To run the tests you need to specify the `redisCluster` flag and have the redis stopped:
// * `go test github.com/cgrates/cgrates/general_tests -tags=integration -dbtype=*mysql -run=TestRedisCluster -redisCluster -v`
// *
// * The configuration of the cluster is the following:
// * - node1 127.0.0.1:7001 master
// * - node2 127.0.0.1:7002 master
// * - node3 127.0.0.1:7003 master
// * - node4 127.0.0.1:7004 replica
// * - node5 127.0.0.1:7005 replica
// * - node6 127.0.0.1:7006 replica
// * The replicas do not allways select the same master
// */
var (
clsrConfig *config.CGRConfig
clsrRPC *rpc.Client
// var (
// clsrConfig *config.CGRConfig
// clsrRPC *rpc.Client
clsrNodeCfgPath = path.Join(*dataDir, "redisCluster", "node%v.conf")
clsrEngineCfgPath = path.Join(*dataDir, "conf", "samples", "redisCluster")
clsrNodes = make(map[string]*exec.Cmd)
clsrOutput = make(map[string]*bytes.Buffer) // in order to debug if something is not working
clsrNoNodes = 6 // this is the minimum number of nodes for a cluster with 1 replica for each master
clsrRedisFlag = flag.Bool("redisCluster", false, "Run tests for redis cluster")
clsrTests = []func(t *testing.T){
testClsrPrepare,
testClsrStartNodes,
testClsrCreateCluster,
testClsrInitConfig,
testClsrFlushDb,
testClsrStartEngine,
testClsrRPCConection,
testClsrSetGetAttribute,
testClsrStopMaster,
testClsrSetGetAttribute2,
testClsrReStartMaster,
testClsrGetAttribute,
testClsrStopNodes,
testClsrKillEngine,
testClsrDeleteFolder,
// testClsrPrintOutput,
}
// clsrNodeCfgPath = path.Join(*dataDir, "redisCluster", "node%v.conf")
// clsrEngineCfgPath = path.Join(*dataDir, "conf", "samples", "redisCluster")
// clsrNodes = make(map[string]*exec.Cmd)
// clsrOutput = make(map[string]*bytes.Buffer) // in order to debug if something is not working
// clsrNoNodes = 6 // this is the minimum number of nodes for a cluster with 1 replica for each master
// clsrRedisFlag = flag.Bool("redisCluster", false, "Run tests for redis cluster")
// clsrTests = []func(t *testing.T){
// testClsrPrepare,
// testClsrStartNodes,
// testClsrCreateCluster,
// testClsrInitConfig,
// testClsrFlushDb,
// testClsrStartEngine,
// testClsrRPCConection,
// testClsrSetGetAttribute,
// testClsrStopMaster,
// testClsrSetGetAttribute2,
// testClsrReStartMaster,
// testClsrGetAttribute,
// testClsrStopNodes,
// testClsrKillEngine,
// testClsrDeleteFolder,
// // testClsrPrintOutput,
// }
clsrRedisCliArgs = []string{
"--cluster", "create",
"127.0.0.1:7001",
"127.0.0.1:7002",
"127.0.0.1:7003",
"127.0.0.1:7004",
"127.0.0.1:7005",
"127.0.0.1:7006",
"--cluster-replicas", "1",
}
)
// clsrRedisCliArgs = []string{
// "--cluster", "create",
// "127.0.0.1:7001",
// "127.0.0.1:7002",
// "127.0.0.1:7003",
// "127.0.0.1:7004",
// "127.0.0.1:7005",
// "127.0.0.1:7006",
// "--cluster-replicas", "1",
// }
// )
const (
clsrRedisCmd = "redis-server"
clsrRedisCliCmd = "redis-cli"
clsrDir = "/tmp/cluster/"
)
// const (
// clsrRedisCmd = "redis-server"
// clsrRedisCliCmd = "redis-cli"
// clsrDir = "/tmp/cluster/"
// )
func TestRedisCluster(t *testing.T) {
if !*clsrRedisFlag {
t.SkipNow()
}
switch *dbType {
case utils.MetaMySQL:
case utils.MetaInternal,
utils.MetaMongo,
utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range clsrTests {
t.Run("TestRedisCluster", stest)
}
}
// func TestRedisCluster(t *testing.T) {
// if !*clsrRedisFlag {
// t.SkipNow()
// }
// switch *dbType {
// case utils.MetaMySQL:
// case utils.MetaInternal,
// utils.MetaMongo,
// utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range clsrTests {
// t.Run("TestRedisCluster", stest)
// }
// }
func testClsrPrepare(t *testing.T) {
if err := os.MkdirAll(clsrDir, 0755); err != nil {
t.Fatalf("Error creating folder<%s>:%s", clsrDir, err)
}
}
// func testClsrPrepare(t *testing.T) {
// if err := os.MkdirAll(clsrDir, 0755); err != nil {
// t.Fatalf("Error creating folder<%s>:%s", clsrDir, err)
// }
// }
func testClsrStartNodes(t *testing.T) {
for i := 1; i <= clsrNoNodes; i++ {
path := fmt.Sprintf(clsrNodeCfgPath, i)
clsrNodes[path] = exec.Command(clsrRedisCmd, path)
clsrOutput[path] = bytes.NewBuffer(nil)
clsrNodes[path].Stdout = clsrOutput[path]
if err := clsrNodes[path].Start(); err != nil {
t.Fatalf("Could not start node %v because %s", i, err)
}
}
}
// func testClsrStartNodes(t *testing.T) {
// for i := 1; i <= clsrNoNodes; i++ {
// path := fmt.Sprintf(clsrNodeCfgPath, i)
// clsrNodes[path] = exec.Command(clsrRedisCmd, path)
// clsrOutput[path] = bytes.NewBuffer(nil)
// clsrNodes[path].Stdout = clsrOutput[path]
// if err := clsrNodes[path].Start(); err != nil {
// t.Fatalf("Could not start node %v because %s", i, err)
// }
// }
// }
func testClsrCreateCluster(t *testing.T) {
cmd := exec.Command(clsrRedisCliCmd, clsrRedisCliArgs...)
cmd.Stdin = bytes.NewBuffer([]byte("yes\n"))
var stdOut bytes.Buffer
cmd.Stdout = &stdOut
if err := cmd.Run(); err != nil {
t.Errorf("Could not create the cluster because %s", err)
t.Logf("The output was:\n %s", stdOut.String()) // print the output to debug the error
}
time.Sleep(200 * time.Millisecond)
}
// func testClsrCreateCluster(t *testing.T) {
// cmd := exec.Command(clsrRedisCliCmd, clsrRedisCliArgs...)
// cmd.Stdin = bytes.NewBuffer([]byte("yes\n"))
// var stdOut bytes.Buffer
// cmd.Stdout = &stdOut
// if err := cmd.Run(); err != nil {
// t.Errorf("Could not create the cluster because %s", err)
// t.Logf("The output was:\n %s", stdOut.String()) // print the output to debug the error
// }
// time.Sleep(200 * time.Millisecond)
// }
func testClsrInitConfig(t *testing.T) {
var err error
clsrConfig, err = config.NewCGRConfigFromPath(clsrEngineCfgPath)
if err != nil {
t.Error(err)
}
clsrConfig.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush()
}
// func testClsrInitConfig(t *testing.T) {
// var err error
// clsrConfig, err = config.NewCGRConfigFromPath(clsrEngineCfgPath)
// if err != nil {
// t.Error(err)
// }
// clsrConfig.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush()
// }
func testClsrFlushDb(t *testing.T) {
if err := engine.InitDataDB(clsrConfig); err != nil {
t.Fatal(err)
}
}
// func testClsrFlushDb(t *testing.T) {
// if err := engine.InitDataDB(clsrConfig); err != nil {
// t.Fatal(err)
// }
// }
func testClsrStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(clsrEngineCfgPath, 200); err != nil {
t.Fatal(err)
}
}
// func testClsrStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(clsrEngineCfgPath, 200); err != nil {
// t.Fatal(err)
// }
// }
func testClsrRPCConection(t *testing.T) {
var err error
clsrRPC, err = newRPCClient(clsrConfig.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal(err)
}
}
// func testClsrRPCConection(t *testing.T) {
// var err error
// clsrRPC, err = newRPCClient(clsrConfig.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal(err)
// }
// }
func testClsrSetGetAttribute(t *testing.T) {
alsPrf := &engine.AttributeProfile{
Tenant: "cgrates.org",
ID: "ClsrTest",
FilterIDs: []string{"*string:~*req.Account:1001", "*string:~*opts.*context:*sessions|*cdrs"},
Attributes: []*engine.Attribute{
{
Path: utils.MetaReq + utils.NestingSep + utils.Subject,
Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep),
},
},
Weight: 20,
}
alsPrf.Compile()
var result string
if err := clsrRPC.Call(utils.APIerSv1SetAttributeProfile, alsPrf, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
var reply *engine.AttributeProfile
if err := clsrRPC.Call(utils.APIerSv1GetAttributeProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "ClsrTest"}, &reply); err != nil {
t.Fatal(err)
}
reply.Compile()
if !reflect.DeepEqual(alsPrf, reply) {
t.Errorf("Expecting : %+v, received: %+v", alsPrf, reply)
}
}
// func testClsrSetGetAttribute(t *testing.T) {
// alsPrf := &engine.AttributeProfile{
// Tenant: "cgrates.org",
// ID: "ClsrTest",
// FilterIDs: []string{"*string:~*req.Account:1001", "*string:~*opts.*context:*sessions|*cdrs"},
// Attributes: []*engine.Attribute{
// {
// Path: utils.MetaReq + utils.NestingSep + utils.Subject,
// Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep),
// },
// },
// Weight: 20,
// }
// alsPrf.Compile()
// var result string
// if err := clsrRPC.Call(utils.APIerSv1SetAttributeProfile, alsPrf, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
// var reply *engine.AttributeProfile
// if err := clsrRPC.Call(utils.APIerSv1GetAttributeProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "ClsrTest"}, &reply); err != nil {
// t.Fatal(err)
// }
// reply.Compile()
// if !reflect.DeepEqual(alsPrf, reply) {
// t.Errorf("Expecting : %+v, received: %+v", alsPrf, reply)
// }
// }
func testClsrStopMaster(t *testing.T) {
path := fmt.Sprintf(clsrNodeCfgPath, 3)
if err = clsrNodes[path].Process.Kill(); err != nil {
t.Fatal(err)
}
time.Sleep(time.Second)
}
// func testClsrStopMaster(t *testing.T) {
// path := fmt.Sprintf(clsrNodeCfgPath, 3)
// if err = clsrNodes[path].Process.Kill(); err != nil {
// t.Fatal(err)
// }
// time.Sleep(time.Second)
// }
func testClsrSetGetAttribute2(t *testing.T) {
alsPrf := &engine.AttributeProfile{
Tenant: "cgrates.org",
ID: "ClsrTest",
FilterIDs: []string{"*string:~*req.Account:1001", "*string:~*opts.*context:*sessions|*cdrs"},
Attributes: []*engine.Attribute{
{
Path: utils.MetaReq + utils.NestingSep + utils.Subject,
Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep),
},
},
Weight: 20,
}
alsPrf.Compile()
var reply *engine.AttributeProfile
if err := clsrRPC.Call(utils.APIerSv1GetAttributeProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "ClsrTest"}, &reply); err != nil {
t.Fatal(err)
}
reply.Compile()
if !reflect.DeepEqual(alsPrf, reply) {
t.Errorf("Expecting : %+v, received: %+v", alsPrf, reply)
}
// add another attribute
alsPrf.ID += "2"
var result string
if err := clsrRPC.Call(utils.APIerSv1SetAttributeProfile, alsPrf, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
}
// func testClsrSetGetAttribute2(t *testing.T) {
// alsPrf := &engine.AttributeProfile{
// Tenant: "cgrates.org",
// ID: "ClsrTest",
// FilterIDs: []string{"*string:~*req.Account:1001", "*string:~*opts.*context:*sessions|*cdrs"},
// Attributes: []*engine.Attribute{
// {
// Path: utils.MetaReq + utils.NestingSep + utils.Subject,
// Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep),
// },
// },
// Weight: 20,
// }
// alsPrf.Compile()
// var reply *engine.AttributeProfile
// if err := clsrRPC.Call(utils.APIerSv1GetAttributeProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "ClsrTest"}, &reply); err != nil {
// t.Fatal(err)
// }
// reply.Compile()
// if !reflect.DeepEqual(alsPrf, reply) {
// t.Errorf("Expecting : %+v, received: %+v", alsPrf, reply)
// }
// // add another attribute
// alsPrf.ID += "2"
// var result string
// if err := clsrRPC.Call(utils.APIerSv1SetAttributeProfile, alsPrf, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
// }
func testClsrReStartMaster(t *testing.T) {
path := fmt.Sprintf(clsrNodeCfgPath, 3)
clsrNodes[path] = exec.Command(clsrRedisCmd, path)
clsrOutput[path] = bytes.NewBuffer(nil)
clsrNodes[path].Stdout = clsrOutput[path]
if err := clsrNodes[path].Start(); err != nil {
t.Fatalf("Could not start node %v because %s", 3, err)
}
time.Sleep(200 * time.Millisecond)
}
// func testClsrReStartMaster(t *testing.T) {
// path := fmt.Sprintf(clsrNodeCfgPath, 3)
// clsrNodes[path] = exec.Command(clsrRedisCmd, path)
// clsrOutput[path] = bytes.NewBuffer(nil)
// clsrNodes[path].Stdout = clsrOutput[path]
// if err := clsrNodes[path].Start(); err != nil {
// t.Fatalf("Could not start node %v because %s", 3, err)
// }
// time.Sleep(200 * time.Millisecond)
// }
func testClsrGetAttribute(t *testing.T) {
alsPrf := &engine.AttributeProfile{
Tenant: "cgrates.org",
ID: "ClsrTest2",
FilterIDs: []string{"*string:~*req.Account:1001", "*string:~*opts.*context:*sessions|*cdrs"},
Attributes: []*engine.Attribute{
{
Path: utils.MetaReq + utils.NestingSep + utils.Subject,
Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep),
},
},
Weight: 20,
}
alsPrf.Compile()
var reply *engine.AttributeProfile
if err := clsrRPC.Call(utils.APIerSv1GetAttributeProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "ClsrTest2"}, &reply); err != nil {
t.Fatal(err)
}
reply.Compile()
if !reflect.DeepEqual(alsPrf, reply) {
t.Errorf("Expecting : %+v, received: %+v", alsPrf, reply)
}
}
// func testClsrGetAttribute(t *testing.T) {
// alsPrf := &engine.AttributeProfile{
// Tenant: "cgrates.org",
// ID: "ClsrTest2",
// FilterIDs: []string{"*string:~*req.Account:1001", "*string:~*opts.*context:*sessions|*cdrs"},
// Attributes: []*engine.Attribute{
// {
// Path: utils.MetaReq + utils.NestingSep + utils.Subject,
// Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep),
// },
// },
// Weight: 20,
// }
// alsPrf.Compile()
// var reply *engine.AttributeProfile
// if err := clsrRPC.Call(utils.APIerSv1GetAttributeProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "ClsrTest2"}, &reply); err != nil {
// t.Fatal(err)
// }
// reply.Compile()
// if !reflect.DeepEqual(alsPrf, reply) {
// t.Errorf("Expecting : %+v, received: %+v", alsPrf, reply)
// }
// }
func testClsrStopNodes(t *testing.T) {
for path, node := range clsrNodes {
if err := node.Process.Kill(); err != nil {
t.Fatalf("Could not stop node with path <%s> because %s", path, err)
}
}
}
// func testClsrStopNodes(t *testing.T) {
// for path, node := range clsrNodes {
// if err := node.Process.Kill(); err != nil {
// t.Fatalf("Could not stop node with path <%s> because %s", path, err)
// }
// }
// }
func testClsrPrintOutput(t *testing.T) {
for path, node := range clsrOutput {
t.Logf("The output of the node <%s> is:\n%s", path, node.String())
t.Logf("==========================================================")
}
}
// func testClsrPrintOutput(t *testing.T) {
// for path, node := range clsrOutput {
// t.Logf("The output of the node <%s> is:\n%s", path, node.String())
// t.Logf("==========================================================")
// }
// }
func testClsrKillEngine(t *testing.T) {
if err := engine.KillEngine(200); err != nil {
t.Error(err)
}
}
// func testClsrKillEngine(t *testing.T) {
// if err := engine.KillEngine(200); err != nil {
// t.Error(err)
// }
// }
func testClsrDeleteFolder(t *testing.T) {
if err := os.RemoveAll(clsrDir); err != nil {
t.Fatalf("Error removing folder<%s>: %s", clsrDir, err)
}
}
// func testClsrDeleteFolder(t *testing.T) {
// if err := os.RemoveAll(clsrDir); err != nil {
// t.Fatalf("Error removing folder<%s>: %s", clsrDir, err)
// }
// }

174
general_tests/redis_tls_it_test.go
View File

@@ -21,102 +21,102 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"flag"
"net/rpc"
"os/exec"
"path"
"testing"
// import (
// "flag"
// "net/rpc"
// "os/exec"
// "path"
// "testing"
"github.com/cgrates/cgrates/utils"
// "github.com/cgrates/cgrates/utils"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// )
var (
redisTLS = flag.Bool("redisTLS", false, "Run tests with redis tls")
redisTLSServer *exec.Cmd
redisTLSEngineCfg = path.Join(*dataDir, "conf", "samples", "redisTLS")
redisTLSCfg *config.CGRConfig
redisTLSRPC *rpc.Client
// var (
// redisTLS = flag.Bool("redisTLS", false, "Run tests with redis tls")
// redisTLSServer *exec.Cmd
// redisTLSEngineCfg = path.Join(*dataDir, "conf", "samples", "redisTLS")
// redisTLSCfg *config.CGRConfig
// redisTLSRPC *rpc.Client
sTestsRedisTLS = []func(t *testing.T){
testRedisTLSStartServer,
testRedisTLSInitConfig,
testRedisTLSFlushDb,
testRedisTLSStartEngine,
testRedisTLSRPCCon,
testRedisTLSSetGetAttribute,
testRedisTLSKillEngine,
}
)
// sTestsRedisTLS = []func(t *testing.T){
// testRedisTLSStartServer,
// testRedisTLSInitConfig,
// testRedisTLSFlushDb,
// testRedisTLSStartEngine,
// testRedisTLSRPCCon,
// testRedisTLSSetGetAttribute,
// testRedisTLSKillEngine,
// }
// )
// Before running these tests first you need to make sure you build the redis server with TLS support
// https://redis.io/topics/encryption
func TestRedisTLS(t *testing.T) {
if !*redisTLS {
return
}
for _, stest := range sTestsRedisTLS {
t.Run("TestRedisTLS", stest)
}
}
// // Before running these tests first you need to make sure you build the redis server with TLS support
// // https://redis.io/topics/encryption
// func TestRedisTLS(t *testing.T) {
// if !*redisTLS {
// return
// }
// for _, stest := range sTestsRedisTLS {
// t.Run("TestRedisTLS", stest)
// }
// }
func testRedisTLSStartServer(t *testing.T) {
// start the server with the server.crt server.key and ca.crt from /data/tls ( self sign certificate )
args := []string{
"--tls-port", "6400", "--port", "0", "--tls-cert-file", "/usr/share/cgrates/tls/server.crt",
"--tls-key-file", "/usr/share/cgrates/tls/server.key", "--tls-ca-cert-file", "/usr/share/cgrates/tls/ca.crt",
}
redisTLSServer = exec.Command("redis-server", args...)
if err := redisTLSServer.Start(); err != nil {
t.Error(err)
}
}
// func testRedisTLSStartServer(t *testing.T) {
// // start the server with the server.crt server.key and ca.crt from /data/tls ( self sign certificate )
// args := []string{
// "--tls-port", "6400", "--port", "0", "--tls-cert-file", "/usr/share/cgrates/tls/server.crt",
// "--tls-key-file", "/usr/share/cgrates/tls/server.key", "--tls-ca-cert-file", "/usr/share/cgrates/tls/ca.crt",
// }
// redisTLSServer = exec.Command("redis-server", args...)
// if err := redisTLSServer.Start(); err != nil {
// t.Error(err)
// }
// }
func testRedisTLSInitConfig(t *testing.T) {
var err error
redisTLSCfg, err = config.NewCGRConfigFromPath(redisTLSEngineCfg)
if err != nil {
t.Error(err)
}
}
// func testRedisTLSInitConfig(t *testing.T) {
// var err error
// redisTLSCfg, err = config.NewCGRConfigFromPath(redisTLSEngineCfg)
// if err != nil {
// t.Error(err)
// }
// }
func testRedisTLSFlushDb(t *testing.T) {
if err := engine.InitDataDB(redisTLSCfg); err != nil {
t.Fatal(err)
}
}
// func testRedisTLSFlushDb(t *testing.T) {
// if err := engine.InitDataDB(redisTLSCfg); err != nil {
// t.Fatal(err)
// }
// }
func testRedisTLSStartEngine(t *testing.T) {
// for the engine we will use the client.crt client.key and ca.crt
if _, err := engine.StopStartEngine(redisTLSEngineCfg, 2000); err != nil {
t.Fatal(err)
}
}
// func testRedisTLSStartEngine(t *testing.T) {
// // for the engine we will use the client.crt client.key and ca.crt
// if _, err := engine.StopStartEngine(redisTLSEngineCfg, 2000); err != nil {
// t.Fatal(err)
// }
// }
func testRedisTLSRPCCon(t *testing.T) {
var err error
redisTLSRPC, err = newRPCClient(redisTLSCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal(err)
}
}
// func testRedisTLSRPCCon(t *testing.T) {
// var err error
// redisTLSRPC, err = newRPCClient(redisTLSCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal(err)
// }
// }
func testRedisTLSSetGetAttribute(t *testing.T) {
// status command to check if the engine starts
var rply map[string]interface{}
if err := redisTLSRPC.Call(utils.CoreSv1Status, &utils.TenantWithAPIOpts{}, &rply); err != nil {
t.Error(err)
}
}
// func testRedisTLSSetGetAttribute(t *testing.T) {
// // status command to check if the engine starts
// var rply map[string]interface{}
// if err := redisTLSRPC.Call(utils.CoreSv1Status, &utils.TenantWithAPIOpts{}, &rply); err != nil {
// t.Error(err)
// }
// }
func testRedisTLSKillEngine(t *testing.T) {
if err := engine.KillEngine(2000); err != nil {
t.Error(err)
}
if err := exec.Command("pkill", "redis-server").Run(); err != nil {
t.Error(err)
}
}
// func testRedisTLSKillEngine(t *testing.T) {
// if err := engine.KillEngine(2000); err != nil {
// t.Error(err)
// }
// if err := exec.Command("pkill", "redis-server").Run(); err != nil {
// t.Error(err)
// }
// }

374
general_tests/resourcesv1_it_test.go
View File

@@ -20,205 +20,205 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"net/rpc"
"path"
"testing"
// import (
// "net/rpc"
// "path"
// "testing"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
rlsV1CfgPath string
rlsV1Cfg *config.CGRConfig
rlsV1Rpc *rpc.Client
rlsV1ConfDIR string //run tests for specific configuration
// var (
// rlsV1CfgPath string
// rlsV1Cfg *config.CGRConfig
// rlsV1Rpc *rpc.Client
// rlsV1ConfDIR string //run tests for specific configuration
sTestsRLSV1 = []func(t *testing.T){
testV1RsLoadConfig,
testV1RsInitDataDb,
testV1RsResetStorDb,
testV1RsStartEngine,
testV1RsRpcConn,
testV1RsSetProfile,
testV1RsAllocate,
testV1RsAuthorize,
testV1RsStopEngine,
}
)
// sTestsRLSV1 = []func(t *testing.T){
// testV1RsLoadConfig,
// testV1RsInitDataDb,
// testV1RsResetStorDb,
// testV1RsStartEngine,
// testV1RsRpcConn,
// testV1RsSetProfile,
// testV1RsAllocate,
// testV1RsAuthorize,
// testV1RsStopEngine,
// }
// )
//Test start here
func TestRsV1IT(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
rlsV1ConfDIR = "tutinternal"
case utils.MetaMySQL:
rlsV1ConfDIR = "tutmysql"
case utils.MetaMongo:
rlsV1ConfDIR = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestsRLSV1 {
t.Run(rlsV1ConfDIR, stest)
}
}
// //Test start here
// func TestRsV1IT(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// rlsV1ConfDIR = "tutinternal"
// case utils.MetaMySQL:
// rlsV1ConfDIR = "tutmysql"
// case utils.MetaMongo:
// rlsV1ConfDIR = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sTestsRLSV1 {
// t.Run(rlsV1ConfDIR, stest)
// }
// }
func testV1RsLoadConfig(t *testing.T) {
var err error
rlsV1CfgPath = path.Join(*dataDir, "conf", "samples", rlsV1ConfDIR)
if rlsV1Cfg, err = config.NewCGRConfigFromPath(rlsV1CfgPath); err != nil {
t.Error(err)
}
}
// func testV1RsLoadConfig(t *testing.T) {
// var err error
// rlsV1CfgPath = path.Join(*dataDir, "conf", "samples", rlsV1ConfDIR)
// if rlsV1Cfg, err = config.NewCGRConfigFromPath(rlsV1CfgPath); err != nil {
// t.Error(err)
// }
// }
func testV1RsInitDataDb(t *testing.T) {
if err := engine.InitDataDB(rlsV1Cfg); err != nil {
t.Fatal(err)
}
}
// func testV1RsInitDataDb(t *testing.T) {
// if err := engine.InitDataDB(rlsV1Cfg); err != nil {
// t.Fatal(err)
// }
// }
// Wipe out the cdr database
func testV1RsResetStorDb(t *testing.T) {
if err := engine.InitStorDB(rlsV1Cfg); err != nil {
t.Fatal(err)
}
}
// // Wipe out the cdr database
// func testV1RsResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(rlsV1Cfg); err != nil {
// t.Fatal(err)
// }
// }
func testV1RsStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(rlsV1CfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testV1RsStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(rlsV1CfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testV1RsRpcConn(t *testing.T) {
var err error
rlsV1Rpc, err = newRPCClient(rlsV1Cfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal("Could not connect to rater: ", err.Error())
}
}
// func testV1RsRpcConn(t *testing.T) {
// var err error
// rlsV1Rpc, err = newRPCClient(rlsV1Cfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal("Could not connect to rater: ", err.Error())
// }
// }
func testV1RsSetProfile(t *testing.T) {
rls := &engine.ResourceProfileWithAPIOpts{
ResourceProfile: &engine.ResourceProfile{
Tenant: "cgrates.org",
ID: "RES_GR_TEST",
FilterIDs: []string{"*string:~*req.Account:1001", "*ai:~*req.AnswerTime:2014-07-14T14:25:00Z|2014-07-14T14:26:00Z"},
UsageTTL: -1,
Limit: 2,
AllocationMessage: "Account1Channels",
Weight: 20,
ThresholdIDs: []string{utils.MetaNone},
},
}
var result string
if err := rlsV1Rpc.Call(utils.APIerSv1SetResourceProfile, rls, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
}
// func testV1RsSetProfile(t *testing.T) {
// rls := &engine.ResourceProfileWithAPIOpts{
// ResourceProfile: &engine.ResourceProfile{
// Tenant: "cgrates.org",
// ID: "RES_GR_TEST",
// FilterIDs: []string{"*string:~*req.Account:1001", "*ai:~*req.AnswerTime:2014-07-14T14:25:00Z|2014-07-14T14:26:00Z"},
// UsageTTL: -1,
// Limit: 2,
// AllocationMessage: "Account1Channels",
// Weight: 20,
// ThresholdIDs: []string{utils.MetaNone},
// },
// }
// var result string
// if err := rlsV1Rpc.Call(utils.APIerSv1SetResourceProfile, rls, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
// }
func testV1RsAllocate(t *testing.T) {
argsRU := &utils.CGREvent{
Tenant: "cgrates.org",
ID: utils.UUIDSha1Prefix(),
Event: map[string]interface{}{
"Account": "1001",
"Destination": "1002",
},
APIOpts: map[string]interface{}{
utils.OptsResourcesUsageID: "chan_1",
utils.OptsResourcesUnits: 1,
},
}
var reply string
if err := rlsV1Rpc.Call(utils.ResourceSv1AllocateResources,
argsRU, &reply); err != nil {
t.Error(err)
} else if reply != "Account1Channels" {
t.Error("Unexpected reply returned", reply)
}
// func testV1RsAllocate(t *testing.T) {
// argsRU := &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: utils.UUIDSha1Prefix(),
// Event: map[string]interface{}{
// "Account": "1001",
// "Destination": "1002",
// },
// APIOpts: map[string]interface{}{
// utils.OptsResourcesUsageID: "chan_1",
// utils.OptsResourcesUnits: 1,
// },
// }
// var reply string
// if err := rlsV1Rpc.Call(utils.ResourceSv1AllocateResources,
// argsRU, &reply); err != nil {
// t.Error(err)
// } else if reply != "Account1Channels" {
// t.Error("Unexpected reply returned", reply)
// }
argsRU2 := &utils.CGREvent{
Tenant: "cgrates.org",
ID: utils.UUIDSha1Prefix(),
Event: map[string]interface{}{
"Account": "1001",
"Destination": "1002",
},
APIOpts: map[string]interface{}{
utils.OptsResourcesUsageID: "chan_2",
utils.OptsResourcesUnits: 1,
},
}
if err := rlsV1Rpc.Call(utils.ResourceSv1AllocateResources,
argsRU2, &reply); err != nil {
t.Error(err)
} else if reply != "Account1Channels" {
t.Error("Unexpected reply returned", reply)
}
}
// argsRU2 := &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: utils.UUIDSha1Prefix(),
// Event: map[string]interface{}{
// "Account": "1001",
// "Destination": "1002",
// },
// APIOpts: map[string]interface{}{
// utils.OptsResourcesUsageID: "chan_2",
// utils.OptsResourcesUnits: 1,
// },
// }
// if err := rlsV1Rpc.Call(utils.ResourceSv1AllocateResources,
// argsRU2, &reply); err != nil {
// t.Error(err)
// } else if reply != "Account1Channels" {
// t.Error("Unexpected reply returned", reply)
// }
// }
func testV1RsAuthorize(t *testing.T) {
var reply *engine.Resources
args := &utils.CGREvent{
Tenant: "cgrates.org",
ID: utils.UUIDSha1Prefix(),
Event: map[string]interface{}{
"Account": "1001",
"Destination": "1002",
},
APIOpts: map[string]interface{}{
utils.OptsResourcesUsageID: "RandomUsageID",
},
}
if err := rlsV1Rpc.Call(utils.ResourceSv1GetResourcesForEvent,
args, &reply); err != nil {
t.Error(err)
}
if reply == nil {
t.Errorf("Expecting reply to not be nil")
// reply shoud not be nil so exit function
// to avoid nil segmentation fault;
// if this happens try to run this test manualy
return
}
if len(*reply) != 1 {
t.Errorf("Expecting: %+v, received: %+v", 1, len(*reply))
}
if (*reply)[0].ID != "RES_GR_TEST" {
t.Errorf("Expecting: %+v, received: %+v", "RES_GR_TEST", (*reply)[0].ID)
}
if len((*reply)[0].Usages) != 2 {
t.Errorf("Expecting: %+v, received: %+v", 2, len((*reply)[0].Usages))
}
// func testV1RsAuthorize(t *testing.T) {
// var reply *engine.Resources
// args := &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: utils.UUIDSha1Prefix(),
// Event: map[string]interface{}{
// "Account": "1001",
// "Destination": "1002",
// },
// APIOpts: map[string]interface{}{
// utils.OptsResourcesUsageID: "RandomUsageID",
// },
// }
// if err := rlsV1Rpc.Call(utils.ResourceSv1GetResourcesForEvent,
// args, &reply); err != nil {
// t.Error(err)
// }
// if reply == nil {
// t.Errorf("Expecting reply to not be nil")
// // reply shoud not be nil so exit function
// // to avoid nil segmentation fault;
// // if this happens try to run this test manualy
// return
// }
// if len(*reply) != 1 {
// t.Errorf("Expecting: %+v, received: %+v", 1, len(*reply))
// }
// if (*reply)[0].ID != "RES_GR_TEST" {
// t.Errorf("Expecting: %+v, received: %+v", "RES_GR_TEST", (*reply)[0].ID)
// }
// if len((*reply)[0].Usages) != 2 {
// t.Errorf("Expecting: %+v, received: %+v", 2, len((*reply)[0].Usages))
// }
var reply2 string
argsRU := &utils.CGREvent{
Tenant: "cgrates.org",
ID: utils.UUIDSha1Prefix(),
Event: map[string]interface{}{
"Account": "1001",
"Destination": "1002"},
APIOpts: map[string]interface{}{
utils.OptsResourcesUsageID: "chan_1",
utils.OptsResourcesUnits: 1,
},
}
if err := rlsV1Rpc.Call(utils.ResourceSv1AuthorizeResources,
&argsRU, &reply2); err.Error() != "RESOURCE_UNAUTHORIZED" {
t.Error(err)
}
}
// var reply2 string
// argsRU := &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: utils.UUIDSha1Prefix(),
// Event: map[string]interface{}{
// "Account": "1001",
// "Destination": "1002"},
// APIOpts: map[string]interface{}{
// utils.OptsResourcesUsageID: "chan_1",
// utils.OptsResourcesUnits: 1,
// },
// }
// if err := rlsV1Rpc.Call(utils.ResourceSv1AuthorizeResources,
// &argsRU, &reply2); err.Error() != "RESOURCE_UNAUTHORIZED" {
// t.Error(err)
// }
// }
func testV1RsStopEngine(t *testing.T) {
if err := engine.KillEngine(*waitRater); err != nil {
t.Error(err)
}
}
// func testV1RsStopEngine(t *testing.T) {
// if err := engine.KillEngine(*waitRater); err != nil {
// t.Error(err)
// }
// }

1350
general_tests/route_it_test.go
View File

File diff suppressed because it is too large Load Diff

1660
general_tests/rpccaching_it_test.go
View File

File diff suppressed because it is too large Load Diff

796
general_tests/rpcclient_it_test.go
View File

@@ -21,427 +21,427 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"flag"
"fmt"
"os/exec"
"path"
"testing"
"time"
// import (
// "flag"
// "fmt"
// "os/exec"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/rpcclient"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// "github.com/cgrates/rpcclient"
// )
var testRemoteRALs = flag.Bool("remote_rals", false, "Perform the tests in integration mode, not by default.") // This flag will be passed here via "go test -local" args
// var testRemoteRALs = flag.Bool("remote_rals", false, "Perform the tests in integration mode, not by default.") // This flag will be passed here via "go test -local" args
var ( // shared vars
rpcITCfgPath1, rpcITCfgPath2 string
rpcITCfgDIR1, rpcITCfgDIR2 string
rpcITCfg1, rpcITCfg2 *config.CGRConfig
rpcRAL1, rpcRAL2 *rpcclient.RPCClient
rpcPoolFirst, rpcPoolBroadcast *rpcclient.RPCPool
ral1, ral2 *exec.Cmd
node1 = "node1"
node2 = "node2"
)
// var ( // shared vars
// rpcITCfgPath1, rpcITCfgPath2 string
// rpcITCfgDIR1, rpcITCfgDIR2 string
// rpcITCfg1, rpcITCfg2 *config.CGRConfig
// rpcRAL1, rpcRAL2 *rpcclient.RPCClient
// rpcPoolFirst, rpcPoolBroadcast *rpcclient.RPCPool
// ral1, ral2 *exec.Cmd
// node1 = "node1"
// node2 = "node2"
// )
var ( // configuration opts
RemoteRALsAddr1 = "192.168.244.137:2012"
RemoteRALsAddr2 = "192.168.244.138:2012"
)
// var ( // configuration opts
// RemoteRALsAddr1 = "192.168.244.137:2012"
// RemoteRALsAddr2 = "192.168.244.138:2012"
// )
//subtests to be executed
var sTestRPCITLcl = []func(t *testing.T){
testRPCITLclInitCfg,
testRPCITLclStartSecondEngine,
testRPCITLclRpcConnPoolFirst,
testRPCITLclStatusSecondEngine,
testRPCITLclStartFirstEngine,
testRPCITLclStatusFirstInitial,
testRPCITLclStatusFirstFailover,
testRPCITLclStatusFirstFailback,
testRPCITLclTDirectedRPC,
testRPCITLclRpcConnPoolBcast,
testRPCITLclBcastStatusInitial,
testRPCITLclBcastStatusNoRals1,
testRPCITLclBcastStatusBcastNoRals,
testRPCITLclBcastStatusRALs2Up,
testRPCITLclStatusBcastRALs1Up,
}
// //subtests to be executed
// var sTestRPCITLcl = []func(t *testing.T){
// testRPCITLclInitCfg,
// testRPCITLclStartSecondEngine,
// testRPCITLclRpcConnPoolFirst,
// testRPCITLclStatusSecondEngine,
// testRPCITLclStartFirstEngine,
// testRPCITLclStatusFirstInitial,
// testRPCITLclStatusFirstFailover,
// testRPCITLclStatusFirstFailback,
// testRPCITLclTDirectedRPC,
// testRPCITLclRpcConnPoolBcast,
// testRPCITLclBcastStatusInitial,
// testRPCITLclBcastStatusNoRals1,
// testRPCITLclBcastStatusBcastNoRals,
// testRPCITLclBcastStatusRALs2Up,
// testRPCITLclStatusBcastRALs1Up,
// }
func TestRPCITLcl(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
rpcITCfgDIR1 = "multiral1_internal"
rpcITCfgDIR2 = "multiral2_internal"
case utils.MetaMySQL:
rpcITCfgDIR1 = "multiral1_mysql"
rpcITCfgDIR2 = "multiral2_mysql"
case utils.MetaMongo:
rpcITCfgDIR1 = "multiral1_mongo"
rpcITCfgDIR2 = "multiral2_mongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestRPCITLcl {
t.Run(*dbType, stest)
}
}
// func TestRPCITLcl(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// rpcITCfgDIR1 = "multiral1_internal"
// rpcITCfgDIR2 = "multiral2_internal"
// case utils.MetaMySQL:
// rpcITCfgDIR1 = "multiral1_mysql"
// rpcITCfgDIR2 = "multiral2_mysql"
// case utils.MetaMongo:
// rpcITCfgDIR1 = "multiral1_mongo"
// rpcITCfgDIR2 = "multiral2_mongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sTestRPCITLcl {
// t.Run(*dbType, stest)
// }
// }
func testRPCITLclInitCfg(t *testing.T) {
rpcITCfgPath1 = path.Join(*dataDir, "conf", "samples", rpcITCfgDIR1)
rpcITCfgPath2 = path.Join(*dataDir, "conf", "samples", rpcITCfgDIR2)
rpcITCfg1, err = config.NewCGRConfigFromPath(rpcITCfgPath1)
if err != nil {
t.Error(err)
}
rpcITCfg2, err = config.NewCGRConfigFromPath(rpcITCfgPath2)
if err != nil {
t.Error(err)
}
if err := engine.InitDataDB(rpcITCfg1); err != nil {
t.Fatal(err)
}
}
// func testRPCITLclInitCfg(t *testing.T) {
// rpcITCfgPath1 = path.Join(*dataDir, "conf", "samples", rpcITCfgDIR1)
// rpcITCfgPath2 = path.Join(*dataDir, "conf", "samples", rpcITCfgDIR2)
// rpcITCfg1, err = config.NewCGRConfigFromPath(rpcITCfgPath1)
// if err != nil {
// t.Error(err)
// }
// rpcITCfg2, err = config.NewCGRConfigFromPath(rpcITCfgPath2)
// if err != nil {
// t.Error(err)
// }
// if err := engine.InitDataDB(rpcITCfg1); err != nil {
// t.Fatal(err)
// }
// }
func testRPCITLclStartSecondEngine(t *testing.T) {
if ral2, err = engine.StopStartEngine(rpcITCfgPath2, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testRPCITLclStartSecondEngine(t *testing.T) {
// if ral2, err = engine.StopStartEngine(rpcITCfgPath2, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
// Connect rpc client to rater
func testRPCITLclRpcConnPoolFirst(t *testing.T) {
rpcPoolFirst = rpcclient.NewRPCPool(rpcclient.PoolFirst, 0)
rpcRAL1, err = rpcclient.NewRPCClient(utils.TCP, rpcITCfg1.ListenCfg().RPCJSONListen, false, "", "", "", 3, 1,
time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil)
if err == nil {
t.Fatal("Should receive cannot connect error here")
}
rpcPoolFirst.AddClient(rpcRAL1)
rpcRAL2, err = rpcclient.NewRPCClient(utils.TCP, rpcITCfg2.ListenCfg().RPCJSONListen, false, "", "", "", 3, 1,
time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil)
if err != nil {
t.Fatal(err)
}
rpcPoolFirst.AddClient(rpcRAL2)
}
// // Connect rpc client to rater
// func testRPCITLclRpcConnPoolFirst(t *testing.T) {
// rpcPoolFirst = rpcclient.NewRPCPool(rpcclient.PoolFirst, 0)
// rpcRAL1, err = rpcclient.NewRPCClient(utils.TCP, rpcITCfg1.ListenCfg().RPCJSONListen, false, "", "", "", 3, 1,
// time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil)
// if err == nil {
// t.Fatal("Should receive cannot connect error here")
// }
// rpcPoolFirst.AddClient(rpcRAL1)
// rpcRAL2, err = rpcclient.NewRPCClient(utils.TCP, rpcITCfg2.ListenCfg().RPCJSONListen, false, "", "", "", 3, 1,
// time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil)
// if err != nil {
// t.Fatal(err)
// }
// rpcPoolFirst.AddClient(rpcRAL2)
// }
// Connect rpc client to rater
func testRPCITLclStatusSecondEngine(t *testing.T) {
var status map[string]interface{}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { // Make sure second time we land on the same instance
t.Error(err)
} else if status[utils.NodeID].(string) != node2 {
t.Errorf("Expecting:\n%s\nReceived:\n%s", node2, status[utils.NodeID].(string))
}
}
// Start first engine
func testRPCITLclStartFirstEngine(t *testing.T) {
if ral1, err = engine.StartEngine(rpcITCfgPath1, *waitRater); err != nil {
t.Fatal(err)
}
}
// Connect rpc client to rater
func testRPCITLclStatusFirstInitial(t *testing.T) {
var status map[string]interface{}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
} else if status[utils.NodeID].(string) == node2 {
t.Fatalf("Should receive ralID different than second one, got: %s", status[utils.NodeID].(string))
}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { // Make sure second time we land on the same instance
t.Error(err)
} else if status[utils.NodeID].(string) != node1 {
t.Errorf("Expecting:\n%s\nReceived:\n%s", node1, status[utils.NodeID].(string))
}
}
// Connect rpc client to rater
func testRPCITLclStatusFirstFailover(t *testing.T) {
if err := ral1.Process.Kill(); err != nil { // Kill the first RAL
t.Error(err)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond)
var status map[string]interface{}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
} else if status[utils.NodeID].(string) == node1 {
t.Fatalf("Should receive ralID different than first one, got: %s", status[utils.NodeID].(string))
}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { // Make sure second time we land on the same instance
t.Error(err)
} else if status[utils.NodeID].(string) != node2 {
t.Errorf("Expecting:\n%s\nReceived:\n%s", node2, status[utils.NodeID].(string))
}
}
func testRPCITLclStatusFirstFailback(t *testing.T) {
if ral1, err = engine.StartEngine(rpcITCfgPath1, *waitRater); err != nil {
t.Fatal(err)
}
var status map[string]interface{}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == node2 {
t.Error("Should receive new ID")
}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { // Make sure second time we land on the same instance
t.Error(err)
} else if status[utils.NodeID].(string) != node1 {
t.Errorf("Expecting:\n%s\nReceived:\n%s", node2, status[utils.NodeID].(string))
}
}
// Make sure it executes on the first node supporting the command
func testRPCITLclTDirectedRPC(t *testing.T) {
var sessions []*sessions.ExternalSession
if err := rpcPoolFirst.Call(utils.SessionSv1GetActiveSessions, utils.SessionFilter{}, &sessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
// func testRPCITLclTimeout(t *testing.T) {
// // Connect rpc client to rater
// func testRPCITLclStatusSecondEngine(t *testing.T) {
// var status map[string]interface{}
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, "10s", &status); err == nil {
// t.Error("Expecting timeout")
// } else if err.Error() != rpcclient.ErrReplyTimeout.Error() {
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// }
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { // Make sure second time we land on the same instance
// t.Error(err)
// } else if status[utils.NodeID].(string) != node2 {
// t.Errorf("Expecting:\n%s\nReceived:\n%s", node2, status[utils.NodeID].(string))
// }
// }
// // Start first engine
// func testRPCITLclStartFirstEngine(t *testing.T) {
// if ral1, err = engine.StartEngine(rpcITCfgPath1, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
// // Connect rpc client to rater
// func testRPCITLclStatusFirstInitial(t *testing.T) {
// var status map[string]interface{}
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// } else if status[utils.NodeID].(string) == node2 {
// t.Fatalf("Should receive ralID different than second one, got: %s", status[utils.NodeID].(string))
// }
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { // Make sure second time we land on the same instance
// t.Error(err)
// } else if status[utils.NodeID].(string) != node1 {
// t.Errorf("Expecting:\n%s\nReceived:\n%s", node1, status[utils.NodeID].(string))
// }
// }
// // Connect rpc client to rater
// func testRPCITLclStatusFirstFailover(t *testing.T) {
// if err := ral1.Process.Kill(); err != nil { // Kill the first RAL
// t.Error(err)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond)
// var status map[string]interface{}
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// } else if status[utils.NodeID].(string) == node1 {
// t.Fatalf("Should receive ralID different than first one, got: %s", status[utils.NodeID].(string))
// }
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { // Make sure second time we land on the same instance
// t.Error(err)
// } else if status[utils.NodeID].(string) != node2 {
// t.Errorf("Expecting:\n%s\nReceived:\n%s", node2, status[utils.NodeID].(string))
// }
// }
// func testRPCITLclStatusFirstFailback(t *testing.T) {
// if ral1, err = engine.StartEngine(rpcITCfgPath1, *waitRater); err != nil {
// t.Fatal(err)
// }
// var status map[string]interface{}
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == node2 {
// t.Error("Should receive new ID")
// }
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { // Make sure second time we land on the same instance
// t.Error(err)
// } else if status[utils.NodeID].(string) != node1 {
// t.Errorf("Expecting:\n%s\nReceived:\n%s", node2, status[utils.NodeID].(string))
// }
// }
// // Make sure it executes on the first node supporting the command
// func testRPCITLclTDirectedRPC(t *testing.T) {
// var sessions []*sessions.ExternalSession
// if err := rpcPoolFirst.Call(utils.SessionSv1GetActiveSessions, utils.SessionFilter{}, &sessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// }
// Connect rpc client to rater
func testRPCITLclRpcConnPoolBcast(t *testing.T) {
rpcPoolBroadcast = rpcclient.NewRPCPool(rpcclient.PoolBroadcast, 2*time.Second)
rpcPoolBroadcast.AddClient(rpcRAL1)
rpcPoolBroadcast.AddClient(rpcRAL2)
}
// // func testRPCITLclTimeout(t *testing.T) {
// // var status map[string]interface{}
// // if err := rpcPoolFirst.Call(utils.CoreSv1Status, "10s", &status); err == nil {
// // t.Error("Expecting timeout")
// // } else if err.Error() != rpcclient.ErrReplyTimeout.Error() {
// // t.Error(err)
// // }
// // }
func testRPCITLclBcastStatusInitial(t *testing.T) {
var status map[string]interface{}
if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
}
if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
}
}
// // Connect rpc client to rater
// func testRPCITLclRpcConnPoolBcast(t *testing.T) {
// rpcPoolBroadcast = rpcclient.NewRPCPool(rpcclient.PoolBroadcast, 2*time.Second)
// rpcPoolBroadcast.AddClient(rpcRAL1)
// rpcPoolBroadcast.AddClient(rpcRAL2)
// }
func testRPCITLclBcastStatusNoRals1(t *testing.T) {
if err := ral1.Process.Kill(); err != nil { // Kill the first RAL
t.Error(err)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond)
var status map[string]interface{}
if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
}
if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
}
}
// func testRPCITLclBcastStatusInitial(t *testing.T) {
// var status map[string]interface{}
// if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// }
// if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// }
// }
func testRPCITLclBcastStatusBcastNoRals(t *testing.T) {
if err := ral2.Process.Kill(); err != nil { // Kill the first RAL
t.Error(err)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond)
var status map[string]interface{}
if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err == nil {
t.Error("Should get error")
}
}
// func testRPCITLclBcastStatusNoRals1(t *testing.T) {
// if err := ral1.Process.Kill(); err != nil { // Kill the first RAL
// t.Error(err)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond)
// var status map[string]interface{}
// if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// }
// if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// }
// }
func testRPCITLclBcastStatusRALs2Up(t *testing.T) {
if ral2, err = engine.StartEngine(rpcITCfgPath2, *waitRater); err != nil {
t.Fatal(err)
}
var status map[string]interface{}
if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
}
if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
}
}
// func testRPCITLclBcastStatusBcastNoRals(t *testing.T) {
// if err := ral2.Process.Kill(); err != nil { // Kill the first RAL
// t.Error(err)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond)
// var status map[string]interface{}
// if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err == nil {
// t.Error("Should get error")
// }
// }
func testRPCITLclStatusBcastRALs1Up(t *testing.T) {
if ral1, err = engine.StartEngine(rpcITCfgPath1, *waitRater); err != nil {
t.Fatal(err)
}
var status map[string]interface{}
if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty InstanceID received")
}
if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty InstanceID received")
}
}
// func testRPCITLclBcastStatusRALs2Up(t *testing.T) {
// if ral2, err = engine.StartEngine(rpcITCfgPath2, *waitRater); err != nil {
// t.Fatal(err)
// }
// var status map[string]interface{}
// if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// }
// if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// }
// }
/*
func TestRPCITStatusBcastCmd(t *testing.T) {
var stats utils.CacheStats
if err := rpcRAL1.Call(utils.APIerSv2GetCacheStats, utils.AttrCacheStats{}, &stats); err != nil {
t.Error(err)
} else if stats.LastRatingLoadID != utils.NotAvailable || stats.LastAccountingLoadID != utils.NotAvailable {
t.Errorf("Received unexpected stats: %+v", stats)
}
var loadInst utils.LoadInstance
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(**dataDir, "tariffplans", "oldtutorial")}
if err := rpcRAL1.Call(utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil {
t.Error(err)
} else if loadInst.RatingLoadID == "" || loadInst.AccountingLoadID == "" {
t.Errorf("Empty loadId received, loadInstance: %+v", loadInst)
}
var reply string
if err := rpcPoolBroadcast.Call(utils.APIerSv1ReloadCache, utils.AttrReloadCache{}, &reply); err != nil {
t.Error("Got error on APIerSv1.ReloadCache: ", err.Error())
} else if reply != utils.OK {
t.Error("Calling APIerSv1.ReloadCache got reply: ", reply)
}
if err := rpcRAL1.Call(utils.APIerSv2GetCacheStats, utils.AttrCacheStats{}, &stats); err != nil {
t.Error(err)
} else if stats.LastRatingLoadID != loadInst.RatingLoadID {
t.Errorf("Received unexpected stats: %+v vs %+v", stats, loadInst)
}
if err := rpcRAL2.Call(utils.APIerSv2GetCacheStats, utils.AttrCacheStats{}, &stats); err != nil {
t.Error(err)
} else if stats.LastRatingLoadID != loadInst.RatingLoadID {
t.Errorf("Received unexpected stats: %+v vs %+v", stats, loadInst)
}
}
*/
// func testRPCITLclStatusBcastRALs1Up(t *testing.T) {
// if ral1, err = engine.StartEngine(rpcITCfgPath1, *waitRater); err != nil {
// t.Fatal(err)
// }
// var status map[string]interface{}
// if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty InstanceID received")
// }
// if err := rpcPoolBroadcast.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty InstanceID received")
// }
// }
// Special tests involving remote server (manually set)
// The server network will be manually disconnected without TCP close
// Run remote ones with: go test -tags=integration -run="TestRPCITRmt|TestRPCITStop" -remote_rals
func TestRPCITRmtRpcConnPool(t *testing.T) {
if !*testRemoteRALs {
return
}
rpcPoolFirst = rpcclient.NewRPCPool(rpcclient.PoolFirst, 0)
rpcRALRmt, err := rpcclient.NewRPCClient(utils.TCP, RemoteRALsAddr1, false, "", "", "", 1, 1,
time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil)
if err != nil {
t.Fatal(err)
}
rpcPoolFirst.AddClient(rpcRALRmt)
rpcRAL1, err = rpcclient.NewRPCClient(utils.TCP, RemoteRALsAddr2, false, "", "", "", 1, 1,
time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil)
if err != nil {
t.Fatal(err)
}
rpcPoolFirst.AddClient(rpcRAL1)
}
// /*
// func TestRPCITStatusBcastCmd(t *testing.T) {
// var stats utils.CacheStats
// if err := rpcRAL1.Call(utils.APIerSv2GetCacheStats, utils.AttrCacheStats{}, &stats); err != nil {
// t.Error(err)
// } else if stats.LastRatingLoadID != utils.NotAvailable || stats.LastAccountingLoadID != utils.NotAvailable {
// t.Errorf("Received unexpected stats: %+v", stats)
// }
// var loadInst utils.LoadInstance
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(**dataDir, "tariffplans", "oldtutorial")}
// if err := rpcRAL1.Call(utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil {
// t.Error(err)
// } else if loadInst.RatingLoadID == "" || loadInst.AccountingLoadID == "" {
// t.Errorf("Empty loadId received, loadInstance: %+v", loadInst)
// }
// var reply string
// if err := rpcPoolBroadcast.Call(utils.APIerSv1ReloadCache, utils.AttrReloadCache{}, &reply); err != nil {
// t.Error("Got error on APIerSv1.ReloadCache: ", err.Error())
// } else if reply != utils.OK {
// t.Error("Calling APIerSv1.ReloadCache got reply: ", reply)
// }
// if err := rpcRAL1.Call(utils.APIerSv2GetCacheStats, utils.AttrCacheStats{}, &stats); err != nil {
// t.Error(err)
// } else if stats.LastRatingLoadID != loadInst.RatingLoadID {
// t.Errorf("Received unexpected stats: %+v vs %+v", stats, loadInst)
// }
// if err := rpcRAL2.Call(utils.APIerSv2GetCacheStats, utils.AttrCacheStats{}, &stats); err != nil {
// t.Error(err)
// } else if stats.LastRatingLoadID != loadInst.RatingLoadID {
// t.Errorf("Received unexpected stats: %+v vs %+v", stats, loadInst)
// }
// }
// */
func TestRPCITRmtStatusFirstInitial(t *testing.T) {
if !*testRemoteRALs {
return
}
var status map[string]interface{}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { // Make sure second time we land on the same instance
t.Error(err)
} else if status[utils.NodeID].(string) != node1 {
t.Errorf("Expecting:\n%s\nReceived:\n%s", node1, status[utils.NodeID].(string))
}
}
// // Special tests involving remote server (manually set)
// // The server network will be manually disconnected without TCP close
// // Run remote ones with: go test -tags=integration -run="TestRPCITRmt|TestRPCITStop" -remote_rals
// func TestRPCITRmtRpcConnPool(t *testing.T) {
// if !*testRemoteRALs {
// return
// }
// rpcPoolFirst = rpcclient.NewRPCPool(rpcclient.PoolFirst, 0)
// rpcRALRmt, err := rpcclient.NewRPCClient(utils.TCP, RemoteRALsAddr1, false, "", "", "", 1, 1,
// time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil)
// if err != nil {
// t.Fatal(err)
// }
// rpcPoolFirst.AddClient(rpcRALRmt)
// rpcRAL1, err = rpcclient.NewRPCClient(utils.TCP, RemoteRALsAddr2, false, "", "", "", 1, 1,
// time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil)
// if err != nil {
// t.Fatal(err)
// }
// rpcPoolFirst.AddClient(rpcRAL1)
// }
func TestRPCITRmtStatusFirstFailover(t *testing.T) {
if !*testRemoteRALs {
return
}
fmt.Println("Ready for doing failover")
remaining := 5
for i := 0; i < remaining; i++ {
fmt.Printf("\n\t%d", remaining-i)
time.Sleep(time.Second)
}
fmt.Println("\n\nExecuting query ...")
var status map[string]interface{}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
} else if status[utils.NodeID].(string) == node1 {
t.Fatal("Did not failover")
}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
} else if status[utils.NodeID].(string) != node2 {
t.Fatal("Did not do failover")
}
}
// func TestRPCITRmtStatusFirstInitial(t *testing.T) {
// if !*testRemoteRALs {
// return
// }
// var status map[string]interface{}
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// }
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { // Make sure second time we land on the same instance
// t.Error(err)
// } else if status[utils.NodeID].(string) != node1 {
// t.Errorf("Expecting:\n%s\nReceived:\n%s", node1, status[utils.NodeID].(string))
// }
// }
func TestRPCITRmtStatusFirstFailback(t *testing.T) {
if !*testRemoteRALs {
return
}
fmt.Println("Ready for doing failback")
remaining := 10
for i := 0; i < remaining; i++ {
fmt.Printf("\n\t%d", remaining-i)
time.Sleep(time.Second)
}
fmt.Println("\n\nExecuting query ...")
var status map[string]interface{}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
} else if status[utils.NodeID].(string) == node2 {
t.Fatal("Did not do failback")
}
if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
t.Error(err)
} else if status[utils.NodeID].(string) == "" {
t.Error("Empty NodeID received")
} else if status[utils.NodeID].(string) != node1 {
t.Fatal("Did not do failback")
}
}
// func TestRPCITRmtStatusFirstFailover(t *testing.T) {
// if !*testRemoteRALs {
// return
// }
// fmt.Println("Ready for doing failover")
// remaining := 5
// for i := 0; i < remaining; i++ {
// fmt.Printf("\n\t%d", remaining-i)
// time.Sleep(time.Second)
// }
// fmt.Println("\n\nExecuting query ...")
// var status map[string]interface{}
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// } else if status[utils.NodeID].(string) == node1 {
// t.Fatal("Did not failover")
// }
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// } else if status[utils.NodeID].(string) != node2 {
// t.Fatal("Did not do failover")
// }
// }
func TestRPCITStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func TestRPCITRmtStatusFirstFailback(t *testing.T) {
// if !*testRemoteRALs {
// return
// }
// fmt.Println("Ready for doing failback")
// remaining := 10
// for i := 0; i < remaining; i++ {
// fmt.Printf("\n\t%d", remaining-i)
// time.Sleep(time.Second)
// }
// fmt.Println("\n\nExecuting query ...")
// var status map[string]interface{}
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// } else if status[utils.NodeID].(string) == node2 {
// t.Fatal("Did not do failback")
// }
// if err := rpcPoolFirst.Call(utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil {
// t.Error(err)
// } else if status[utils.NodeID].(string) == "" {
// t.Error("Empty NodeID received")
// } else if status[utils.NodeID].(string) != node1 {
// t.Fatal("Did not do failback")
// }
// }
// func TestRPCITStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

285
general_tests/sentinel_it_test.go
View File

@@ -20,288 +20,3 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"flag"
"net/rpc"
"os"
"os/exec"
"path"
"reflect"
"strconv"
"testing"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
var (
node1ConfigPath = path.Join(*dataDir, "redisSentinel", "node1.conf")
node2ConfigPath = path.Join(*dataDir, "redisSentinel", "node2.conf")
sentinel1ConfigPath = path.Join(*dataDir, "redisSentinel", "sentinel1.conf")
sentinel2ConfigPath = path.Join(*dataDir, "redisSentinel", "sentinel2.conf")
engineConfigPath = path.Join(*dataDir, "conf", "samples", "redisSentinel")
sentinelConfig *config.CGRConfig
sentinelRPC *rpc.Client
node1Exec *exec.Cmd
node2Exec *exec.Cmd
stlExec1 *exec.Cmd
stlExec2 *exec.Cmd
redisSentinel = flag.Bool("redisSentinel", false, "Run tests with redis sentinel")
sTestsRds = []func(t *testing.T){
testRedisSentinelStartNodes,
testRedisSentinelInitConfig,
testRedisSentinelFlushDb,
testRedisSentinelStartEngine,
testRedisSentinelRPCCon,
testRedisSentinelSetGetAttribute,
testRedisSentinelInsertion,
testRedisSentinelGetAttrAfterFailover,
testRedisSentinelKillEngine,
}
)
// Before running these tests make sure node1.conf, node2.conf, sentinel1.conf are the next
// Node1 will be master and start at port 16379
// Node2 will be slave of node1 and start at port 16380
// Sentinel1 will be started at port 16381 and will watch Node1
// Sentinel2 will be started at port 16382 and will watch Node1
// Also make sure that redis process is stopped
func TestRedisSentinel(t *testing.T) {
if !*redisSentinel {
return
}
switch *dbType {
case utils.MetaMySQL:
case utils.MetaInternal,
utils.MetaMongo,
utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestsRds {
t.Run("TestRedisSentinel", stest)
}
}
func testRedisSentinelStartNodes(t *testing.T) {
if err := os.MkdirAll("/tmp/sentinel/", 0755); err != nil {
t.Fatal("Error creating folder: /tmp/sentinel/ ", err)
}
node1Exec = exec.Command("redis-server", node1ConfigPath)
if err := node1Exec.Start(); err != nil {
t.Error(err)
}
node2Exec = exec.Command("redis-server", node2ConfigPath)
if err := node2Exec.Start(); err != nil {
t.Error(err)
}
stlExec1 = exec.Command("redis-sentinel", sentinel1ConfigPath)
if err := stlExec1.Start(); err != nil {
t.Error(err)
}
stlExec2 = exec.Command("redis-sentinel", sentinel2ConfigPath)
if err := stlExec2.Start(); err != nil {
t.Error(err)
}
}
func testRedisSentinelInitConfig(t *testing.T) {
var err error
sentinelConfig, err = config.NewCGRConfigFromPath(engineConfigPath)
if err != nil {
t.Error(err)
}
}
func testRedisSentinelFlushDb(t *testing.T) {
if err := engine.InitDataDB(sentinelConfig); err != nil {
t.Fatal(err)
}
}
func testRedisSentinelStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(engineConfigPath, 2000); err != nil {
t.Fatal(err)
}
}
func testRedisSentinelRPCCon(t *testing.T) {
var err error
sentinelRPC, err = newRPCClient(sentinelConfig.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal(err)
}
}
func testRedisSentinelSetGetAttribute(t *testing.T) {
alsPrf := &engine.AttributeProfile{
Tenant: "cgrates.org",
ID: "ApierTest",
FilterIDs: []string{"*string:~*req.Account:1001", "*string:~*opts.*context:*sessions|*cdrs"},
Attributes: []*engine.Attribute{
{
Path: utils.MetaReq + utils.NestingSep + utils.Subject,
Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep),
},
},
Weight: 20,
}
alsPrf.Compile()
var result string
if err := sentinelRPC.Call(utils.APIerSv1SetAttributeProfile, alsPrf, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
var reply *engine.AttributeProfile
if err := sentinelRPC.Call(utils.APIerSv1GetAttributeProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "ApierTest"}, &reply); err != nil {
t.Fatal(err)
}
reply.Compile()
if !reflect.DeepEqual(alsPrf, reply) {
t.Errorf("Expecting : %+v, received: %+v", alsPrf, reply)
}
}
func testRedisSentinelInsertion(t *testing.T) {
var nrFails1, nrFails2 int
alsPrf := &engine.AttributeProfile{
Tenant: "cgrates.org",
ID: "ApierTest",
FilterIDs: []string{"*string:~*reqAccount:1001", "*string:~*opts.*context:*sessions|*cdrs"},
Attributes: []*engine.Attribute{
{
Path: utils.MetaReq + utils.NestingSep + utils.Subject,
Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep),
},
},
Weight: 20,
}
orgiginID := alsPrf.ID + "_"
index := 0
var result string
addFunc := func(t *testing.T, nrFail *int) {
alsPrf.ID = orgiginID + strconv.Itoa(index)
if err := sentinelRPC.Call(utils.APIerSv1SetAttributeProfile, alsPrf, &result); err != nil {
if err.Error() == "SERVER_ERROR: EOF" {
*nrFail = *nrFail + 1
} else {
t.Error(err)
}
}
index++
}
forFunc1 := func(t *testing.T) {
for i := 0; i < 25; i++ {
t.Run("add", func(t *testing.T) {
t.Parallel()
addFunc(t, &nrFails1)
})
if i == 5 {
t.Run("stop1", func(t *testing.T) {
t.Parallel()
if err := node1Exec.Process.Kill(); err != nil {
t.Error(err)
}
if err := stlExec1.Process.Kill(); err != nil {
t.Error(err)
}
})
}
if i == 10 {
t.Run("stop2", func(t *testing.T) {
t.Parallel()
if err := node2Exec.Process.Kill(); err != nil {
t.Error(err)
}
if err := stlExec2.Process.Kill(); err != nil {
t.Error(err)
}
})
}
t.Run("add2", func(t *testing.T) {
t.Parallel()
addFunc(t, &nrFails1)
})
}
}
forFunc2 := func(t *testing.T) {
for i := 0; i < 10; i++ {
t.Run("add", func(t *testing.T) {
t.Parallel()
addFunc(t, &nrFails2)
})
t.Run("add2", func(t *testing.T) {
t.Parallel()
addFunc(t, &nrFails2)
})
}
}
t.Run("for1", forFunc1)
if nrFails1 == 0 {
t.Error("Fail tests in case of failover")
}
node1Exec = exec.Command("redis-server", node1ConfigPath)
if err := node1Exec.Start(); err != nil {
t.Error(err)
}
node2Exec = exec.Command("redis-server", node2ConfigPath)
if err := node2Exec.Start(); err != nil {
t.Error(err)
}
t.Run("for2", forFunc2)
if nrFails2 > 19 {
t.Errorf("Fail tests in case of failback ")
}
}
// After we kill node1 check the data if was replicated in node2
func testRedisSentinelGetAttrAfterFailover(t *testing.T) {
alsPrf := &engine.AttributeProfile{
Tenant: "cgrates.org",
ID: "ApierTest",
FilterIDs: []string{"*string:~*req.Account:1001", "*string:~*opts.*context:*sessions|*cdrs"},
Attributes: []*engine.Attribute{
{
Path: utils.MetaReq + utils.NestingSep + utils.Subject,
Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep),
},
},
Weight: 20,
}
alsPrf.Compile()
var reply *engine.AttributeProfile
if err := sentinelRPC.Call(utils.APIerSv1GetAttributeProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "ApierTest"}, &reply); err != nil {
t.Fatal(err)
}
reply.Compile()
if !reflect.DeepEqual(alsPrf, reply) {
t.Errorf("Expecting : %+v, received: %+v", alsPrf, reply)
}
}
func testRedisSentinelKillEngine(t *testing.T) {
if err := exec.Command("pkill", "redis-server").Run(); err != nil {
t.Error(err)
}
if err := exec.Command("pkill", "redis-sentinel").Run(); err != nil {
t.Error(err)
}
if err := exec.Command("pkill", "redis-ser").Run(); err != nil {
t.Error(err)
}
if err := exec.Command("pkill", "redis-sen").Run(); err != nil {
t.Error(err)
}
if err := engine.KillEngine(2000); err != nil {
t.Error(err)
}
}

506
general_tests/session2_it_test.go
View File

@@ -21,278 +21,278 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// )
var (
ses2CfgDir string
ses2CfgPath string
ses2Cfg *config.CGRConfig
ses2RPC *rpc.Client
// var (
// ses2CfgDir string
// ses2CfgPath string
// ses2Cfg *config.CGRConfig
// ses2RPC *rpc.Client
ses2Tests = []func(t *testing.T){
testSes2ItLoadConfig,
testSes2ItResetDataDB,
testSes2ItResetStorDb,
testSes2ItStartEngine,
testSes2ItRPCConn,
testSes2ItLoadFromFolder,
testSes2ItInitSession,
testSes2ItAsActiveSessions,
testSes2StirAuthenticate,
testSes2StirInit,
testSes2STIRAuthenticate,
testSes2STIRIdentity,
testSes2ItStopCgrEngine,
}
)
// ses2Tests = []func(t *testing.T){
// testSes2ItLoadConfig,
// testSes2ItResetDataDB,
// testSes2ItResetStorDb,
// testSes2ItStartEngine,
// testSes2ItRPCConn,
// testSes2ItLoadFromFolder,
// testSes2ItInitSession,
// testSes2ItAsActiveSessions,
// testSes2StirAuthenticate,
// testSes2StirInit,
// testSes2STIRAuthenticate,
// testSes2STIRIdentity,
// testSes2ItStopCgrEngine,
// }
// )
func TestSes2It(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
ses2CfgDir = "tutinternal"
case utils.MetaMySQL:
ses2CfgDir = "tutmysql"
case utils.MetaMongo:
ses2CfgDir = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range ses2Tests {
t.Run(ses2CfgDir, stest)
}
}
// func TestSes2It(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// ses2CfgDir = "tutinternal"
// case utils.MetaMySQL:
// ses2CfgDir = "tutmysql"
// case utils.MetaMongo:
// ses2CfgDir = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range ses2Tests {
// t.Run(ses2CfgDir, stest)
// }
// }
func testSes2ItLoadConfig(t *testing.T) {
ses2CfgPath = path.Join(*dataDir, "conf", "samples", ses2CfgDir)
if ses2Cfg, err = config.NewCGRConfigFromPath(ses2CfgPath); err != nil {
t.Error(err)
}
}
// func testSes2ItLoadConfig(t *testing.T) {
// ses2CfgPath = path.Join(*dataDir, "conf", "samples", ses2CfgDir)
// if ses2Cfg, err = config.NewCGRConfigFromPath(ses2CfgPath); err != nil {
// t.Error(err)
// }
// }
func testSes2ItResetDataDB(t *testing.T) {
if err := engine.InitDataDB(ses2Cfg); err != nil {
t.Fatal(err)
}
}
// func testSes2ItResetDataDB(t *testing.T) {
// if err := engine.InitDataDB(ses2Cfg); err != nil {
// t.Fatal(err)
// }
// }
func testSes2ItResetStorDb(t *testing.T) {
if err := engine.InitStorDB(ses2Cfg); err != nil {
t.Fatal(err)
}
}
// func testSes2ItResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(ses2Cfg); err != nil {
// t.Fatal(err)
// }
// }
func testSes2ItStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(ses2CfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testSes2ItStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(ses2CfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testSes2ItRPCConn(t *testing.T) {
var err error
ses2RPC, err = newRPCClient(ses2Cfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testSes2ItRPCConn(t *testing.T) {
// var err error
// ses2RPC, err = newRPCClient(ses2Cfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testSes2ItLoadFromFolder(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")}
if err := ses2RPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
}
time.Sleep(100 * time.Millisecond)
}
// func testSes2ItLoadFromFolder(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")}
// if err := ses2RPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// }
// time.Sleep(100 * time.Millisecond)
// }
func testSes2ItInitSession(t *testing.T) {
// Set balance
attrSetBalance := utils.AttrSetBalance{
Tenant: "cgrates.org",
Account: "1001",
BalanceType: utils.MetaVoice,
Value: float64(time.Hour),
Balance: map[string]interface{}{
utils.ID: "TestDynamicDebitBalance",
},
}
var reply string
if err := ses2RPC.Call(utils.APIerSv2SetBalance,
attrSetBalance, &reply); err != nil {
t.Fatal(err)
}
// func testSes2ItInitSession(t *testing.T) {
// // Set balance
// attrSetBalance := utils.AttrSetBalance{
// Tenant: "cgrates.org",
// Account: "1001",
// BalanceType: utils.MetaVoice,
// Value: float64(time.Hour),
// Balance: map[string]interface{}{
// utils.ID: "TestDynamicDebitBalance",
// },
// }
// var reply string
// if err := ses2RPC.Call(utils.APIerSv2SetBalance,
// attrSetBalance, &reply); err != nil {
// t.Fatal(err)
// }
// Init session
initArgs := &sessions.V1InitSessionArgs{
InitSession: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: utils.UUIDSha1Prefix(),
Event: map[string]interface{}{
utils.EventName: "TEST_EVENT",
utils.OriginID: utils.UUIDSha1Prefix(),
utils.ToR: utils.MetaVoice,
utils.Category: "call",
utils.Tenant: "cgrates.org",
utils.AccountField: "1001",
utils.Subject: "1001",
utils.Destination: "1002",
utils.RequestType: utils.MetaPrepaid,
utils.AnswerTime: time.Date(2016, time.January, 5, 18, 31, 05, 0, time.UTC),
},
},
}
var initRpl *sessions.V1InitSessionReply
if err := ses2RPC.Call(utils.SessionSv1InitiateSession,
initArgs, &initRpl); err != nil {
t.Fatal(err)
}
// // Init session
// initArgs := &sessions.V1InitSessionArgs{
// InitSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: utils.UUIDSha1Prefix(),
// Event: map[string]interface{}{
// utils.EventName: "TEST_EVENT",
// utils.OriginID: utils.UUIDSha1Prefix(),
// utils.ToR: utils.MetaVoice,
// utils.Category: "call",
// utils.Tenant: "cgrates.org",
// utils.AccountField: "1001",
// utils.Subject: "1001",
// utils.Destination: "1002",
// utils.RequestType: utils.MetaPrepaid,
// utils.AnswerTime: time.Date(2016, time.January, 5, 18, 31, 05, 0, time.UTC),
// },
// },
// }
// var initRpl *sessions.V1InitSessionReply
// if err := ses2RPC.Call(utils.SessionSv1InitiateSession,
// initArgs, &initRpl); err != nil {
// t.Fatal(err)
// }
}
// }
func testSes2ItAsActiveSessions(t *testing.T) {
var count int
if err := ses2RPC.Call(utils.SessionSv1GetActiveSessionsCount, utils.SessionFilter{
Filters: []string{"*string:~*req.Account:1001"},
}, &count); err != nil {
t.Fatal(err)
} else if count != 2 { // 2 chargers
t.Errorf("Expected 2 session received %v session(s)", count)
}
if err := ses2RPC.Call(utils.SessionSv1GetActiveSessionsCount, utils.SessionFilter{
Filters: []string{"*string:~*req.Account:1002"},
}, &count); err != nil {
t.Fatal(err)
} else if count != 0 {
t.Errorf("Expected 0 session received %v session(s)", count)
}
}
// func testSes2ItAsActiveSessions(t *testing.T) {
// var count int
// if err := ses2RPC.Call(utils.SessionSv1GetActiveSessionsCount, utils.SessionFilter{
// Filters: []string{"*string:~*req.Account:1001"},
// }, &count); err != nil {
// t.Fatal(err)
// } else if count != 2 { // 2 chargers
// t.Errorf("Expected 2 session received %v session(s)", count)
// }
// if err := ses2RPC.Call(utils.SessionSv1GetActiveSessionsCount, utils.SessionFilter{
// Filters: []string{"*string:~*req.Account:1002"},
// }, &count); err != nil {
// t.Fatal(err)
// } else if count != 0 {
// t.Errorf("Expected 0 session received %v session(s)", count)
// }
// }
func testSes2ItStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSes2ItStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }
func testSes2StirAuthenticate(t *testing.T) {
args := &sessions.V1ProcessEventArgs{
Flags: []string{utils.MetaSTIRAuthenticate},
// func testSes2StirAuthenticate(t *testing.T) {
// args := &sessions.V1ProcessEventArgs{
// Flags: []string{utils.MetaSTIRAuthenticate},
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "testSes2StirAuthorize",
Event: map[string]interface{}{
utils.ToR: utils.MetaVoice,
utils.OriginID: "testSes2StirAuthorize",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1001",
utils.Subject: "ANY2CNT",
utils.Destination: "1002",
utils.Usage: 10 * time.Minute,
},
APIOpts: map[string]interface{}{
utils.OptsStirIdentity: "eyJhbGciOiJFUzI1NiIsInBwdCI6InNoYWtlbiIsInR5cCI6InBhc3Nwb3J0IiwieDV1IjoiL3Vzci9zaGFyZS9jZ3JhdGVzL3N0aXIvc3Rpcl9wdWJrZXkucGVtIn0.eyJhdHRlc3QiOiJBIiwiZGVzdCI6eyJ0biI6WyIxMDAyIl19LCJpYXQiOjE1ODcwMzg4MDIsIm9yaWciOnsidG4iOiIxMDAxIn0sIm9yaWdpZCI6IjEyMzQ1NiJ9.cMEMlFnfyTu8uxfeU4RoZTamA7ifFT9Ibwrvi1_LKwL2xAU6fZ_CSIxKbtyOpNhM_sV03x7CfA_v0T4sHkifzg;info=</usr/share/cgrates/stir/stir_pubkey.pem>;ppt=shaken",
},
},
}
var rply sessions.V1ProcessEventReply
if err := ses2RPC.Call(utils.SessionSv1ProcessEvent,
args, &rply); err != nil { // no error verificated with success
t.Error(err)
}
// altered originator
args.APIOpts[utils.OptsStirOriginatorTn] = "1005"
if err := ses2RPC.Call(utils.SessionSv1ProcessEvent,
args, &rply); err == nil || err.Error() != "*stir_authenticate: wrong originatorTn" {
t.Errorf("Expected error :%q ,receved: %v", "*stir_authenticate: wrong originatorTn", err)
}
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "testSes2StirAuthorize",
// Event: map[string]interface{}{
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "testSes2StirAuthorize",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: "1001",
// utils.Subject: "ANY2CNT",
// utils.Destination: "1002",
// utils.Usage: 10 * time.Minute,
// },
// APIOpts: map[string]interface{}{
// utils.OptsStirIdentity: "eyJhbGciOiJFUzI1NiIsInBwdCI6InNoYWtlbiIsInR5cCI6InBhc3Nwb3J0IiwieDV1IjoiL3Vzci9zaGFyZS9jZ3JhdGVzL3N0aXIvc3Rpcl9wdWJrZXkucGVtIn0.eyJhdHRlc3QiOiJBIiwiZGVzdCI6eyJ0biI6WyIxMDAyIl19LCJpYXQiOjE1ODcwMzg4MDIsIm9yaWciOnsidG4iOiIxMDAxIn0sIm9yaWdpZCI6IjEyMzQ1NiJ9.cMEMlFnfyTu8uxfeU4RoZTamA7ifFT9Ibwrvi1_LKwL2xAU6fZ_CSIxKbtyOpNhM_sV03x7CfA_v0T4sHkifzg;info=</usr/share/cgrates/stir/stir_pubkey.pem>;ppt=shaken",
// },
// },
// }
// var rply sessions.V1ProcessEventReply
// if err := ses2RPC.Call(utils.SessionSv1ProcessEvent,
// args, &rply); err != nil { // no error verificated with success
// t.Error(err)
// }
// // altered originator
// args.APIOpts[utils.OptsStirOriginatorTn] = "1005"
// if err := ses2RPC.Call(utils.SessionSv1ProcessEvent,
// args, &rply); err == nil || err.Error() != "*stir_authenticate: wrong originatorTn" {
// t.Errorf("Expected error :%q ,receved: %v", "*stir_authenticate: wrong originatorTn", err)
// }
// altered identity
args.APIOpts[utils.OptsStirIdentity] = "eyJhbGciOiJFUzI1NiIsInBwdCI6InNoYWtlbiIsInR5cCI6InBhc3Nwb3J0IiwieDV1IjoiL3Vzci9zaGFyZS9jZ3JhdGVzL3N0aXIvc3Rpcl9wdWJrZXkucGVtIn0.eyJhdHRlc3QiOiJBIiwiZGVzdCI6eyJ0biI6WyIxMDAyIl19LCJpYXQiOjE1ODcwMzg4MDIsIm9yaWciOnsidG4iOiIxMDA1In0sIm9yaWdpZCI6IjEyMzQ1NiJ9.cMEMlFnfyTu8uxfeU4RoZTamA7ifFT9Ibwrvi1_LKwL2xAU6fZ_CSIxKbtyOpNhM_sV03x7CfA_v0T4sHkifzg;info=</usr/share/cgrates/stir/stir_pubkey.pem>;ppt=shaken"
if err := ses2RPC.Call(utils.SessionSv1ProcessEvent,
args, &rply); err == nil || err.Error() != "*stir_authenticate: crypto/ecdsa: verification error" {
t.Errorf("Expected error :%q ,receved: %v", "*stir_authenticate: crypto/ecdsa: verification error", err)
}
}
// // altered identity
// args.APIOpts[utils.OptsStirIdentity] = "eyJhbGciOiJFUzI1NiIsInBwdCI6InNoYWtlbiIsInR5cCI6InBhc3Nwb3J0IiwieDV1IjoiL3Vzci9zaGFyZS9jZ3JhdGVzL3N0aXIvc3Rpcl9wdWJrZXkucGVtIn0.eyJhdHRlc3QiOiJBIiwiZGVzdCI6eyJ0biI6WyIxMDAyIl19LCJpYXQiOjE1ODcwMzg4MDIsIm9yaWciOnsidG4iOiIxMDA1In0sIm9yaWdpZCI6IjEyMzQ1NiJ9.cMEMlFnfyTu8uxfeU4RoZTamA7ifFT9Ibwrvi1_LKwL2xAU6fZ_CSIxKbtyOpNhM_sV03x7CfA_v0T4sHkifzg;info=</usr/share/cgrates/stir/stir_pubkey.pem>;ppt=shaken"
// if err := ses2RPC.Call(utils.SessionSv1ProcessEvent,
// args, &rply); err == nil || err.Error() != "*stir_authenticate: crypto/ecdsa: verification error" {
// t.Errorf("Expected error :%q ,receved: %v", "*stir_authenticate: crypto/ecdsa: verification error", err)
// }
// }
func testSes2StirInit(t *testing.T) {
args := &sessions.V1ProcessEventArgs{
Flags: []string{utils.MetaSTIRInitiate},
// func testSes2StirInit(t *testing.T) {
// args := &sessions.V1ProcessEventArgs{
// Flags: []string{utils.MetaSTIRInitiate},
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "testSes2StirInit",
Event: map[string]interface{}{
utils.ToR: utils.MetaVoice,
utils.OriginID: "testSes2StirInit",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1001",
utils.Subject: "ANY2CNT",
utils.Destination: "1002",
utils.Usage: 10 * time.Minute,
},
APIOpts: map[string]interface{}{
utils.OptsStirPublicKeyPath: "/usr/share/cgrates/stir/stir_pubkey.pem",
utils.OptsStirPrivateKeyPath: "/usr/share/cgrates/stir/stir_privatekey.pem",
},
},
}
var rply sessions.V1ProcessEventReply
if err := ses2RPC.Call(utils.SessionSv1ProcessEvent,
args, &rply); err != nil { // no error verificated with success
t.Error(err)
}
if err := sessions.AuthStirShaken(rply.STIRIdentity[utils.MetaRaw], "1001", "", "1002", "", utils.NewStringSet([]string{"A"}), 10*time.Minute); err != nil {
t.Fatal(err)
}
}
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "testSes2StirInit",
// Event: map[string]interface{}{
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "testSes2StirInit",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: "1001",
// utils.Subject: "ANY2CNT",
// utils.Destination: "1002",
// utils.Usage: 10 * time.Minute,
// },
// APIOpts: map[string]interface{}{
// utils.OptsStirPublicKeyPath: "/usr/share/cgrates/stir/stir_pubkey.pem",
// utils.OptsStirPrivateKeyPath: "/usr/share/cgrates/stir/stir_privatekey.pem",
// },
// },
// }
// var rply sessions.V1ProcessEventReply
// if err := ses2RPC.Call(utils.SessionSv1ProcessEvent,
// args, &rply); err != nil { // no error verificated with success
// t.Error(err)
// }
// if err := sessions.AuthStirShaken(rply.STIRIdentity[utils.MetaRaw], "1001", "", "1002", "", utils.NewStringSet([]string{"A"}), 10*time.Minute); err != nil {
// t.Fatal(err)
// }
// }
func testSes2STIRAuthenticate(t *testing.T) {
var rply string
if err := ses2RPC.Call(utils.SessionSv1STIRAuthenticate,
&sessions.V1STIRAuthenticateArgs{
Attest: []string{"A"},
PayloadMaxDuration: "-1",
DestinationTn: "1002",
Identity: "eyJhbGciOiJFUzI1NiIsInBwdCI6InNoYWtlbiIsInR5cCI6InBhc3Nwb3J0IiwieDV1IjoiL3Vzci9zaGFyZS9jZ3JhdGVzL3N0aXIvc3Rpcl9wdWJrZXkucGVtIn0.eyJhdHRlc3QiOiJBIiwiZGVzdCI6eyJ0biI6WyIxMDAyIl19LCJpYXQiOjE1ODcwMzg4MDIsIm9yaWciOnsidG4iOiIxMDAxIn0sIm9yaWdpZCI6IjEyMzQ1NiJ9.cMEMlFnfyTu8uxfeU4RoZTamA7ifFT9Ibwrvi1_LKwL2xAU6fZ_CSIxKbtyOpNhM_sV03x7CfA_v0T4sHkifzg;info=</usr/share/cgrates/stir/stir_pubkey.pem>;ppt=shaken",
OriginatorTn: "1001",
}, &rply); err != nil {
t.Fatal(err)
} else if rply != utils.OK {
t.Errorf("Expected: %s ,received: %s", utils.OK, rply)
}
}
// func testSes2STIRAuthenticate(t *testing.T) {
// var rply string
// if err := ses2RPC.Call(utils.SessionSv1STIRAuthenticate,
// &sessions.V1STIRAuthenticateArgs{
// Attest: []string{"A"},
// PayloadMaxDuration: "-1",
// DestinationTn: "1002",
// Identity: "eyJhbGciOiJFUzI1NiIsInBwdCI6InNoYWtlbiIsInR5cCI6InBhc3Nwb3J0IiwieDV1IjoiL3Vzci9zaGFyZS9jZ3JhdGVzL3N0aXIvc3Rpcl9wdWJrZXkucGVtIn0.eyJhdHRlc3QiOiJBIiwiZGVzdCI6eyJ0biI6WyIxMDAyIl19LCJpYXQiOjE1ODcwMzg4MDIsIm9yaWciOnsidG4iOiIxMDAxIn0sIm9yaWdpZCI6IjEyMzQ1NiJ9.cMEMlFnfyTu8uxfeU4RoZTamA7ifFT9Ibwrvi1_LKwL2xAU6fZ_CSIxKbtyOpNhM_sV03x7CfA_v0T4sHkifzg;info=</usr/share/cgrates/stir/stir_pubkey.pem>;ppt=shaken",
// OriginatorTn: "1001",
// }, &rply); err != nil {
// t.Fatal(err)
// } else if rply != utils.OK {
// t.Errorf("Expected: %s ,received: %s", utils.OK, rply)
// }
// }
func testSes2STIRIdentity(t *testing.T) {
payload := &utils.PASSporTPayload{
Dest: utils.PASSporTDestinationsIdentity{Tn: []string{"1002"}},
IAT: 1587019822,
Orig: utils.PASSporTOriginsIdentity{Tn: "1001"},
OrigID: "123456",
}
args := &sessions.V1STIRIdentityArgs{
Payload: payload,
PublicKeyPath: "/usr/share/cgrates/stir/stir_pubkey.pem",
PrivateKeyPath: "/usr/share/cgrates/stir/stir_privatekey.pem",
OverwriteIAT: true,
}
var rply string
if err := ses2RPC.Call(utils.SessionSv1STIRIdentity,
args, &rply); err != nil {
t.Error(err)
}
if err := sessions.AuthStirShaken(rply, "1001", "", "1002", "", utils.NewStringSet([]string{"A"}), 10*time.Minute); err != nil {
t.Fatal(err)
}
}
// func testSes2STIRIdentity(t *testing.T) {
// payload := &utils.PASSporTPayload{
// Dest: utils.PASSporTDestinationsIdentity{Tn: []string{"1002"}},
// IAT: 1587019822,
// Orig: utils.PASSporTOriginsIdentity{Tn: "1001"},
// OrigID: "123456",
// }
// args := &sessions.V1STIRIdentityArgs{
// Payload: payload,
// PublicKeyPath: "/usr/share/cgrates/stir/stir_pubkey.pem",
// PrivateKeyPath: "/usr/share/cgrates/stir/stir_privatekey.pem",
// OverwriteIAT: true,
// }
// var rply string
// if err := ses2RPC.Call(utils.SessionSv1STIRIdentity,
// args, &rply); err != nil {
// t.Error(err)
// }
// if err := sessions.AuthStirShaken(rply, "1001", "", "1002", "", utils.NewStringSet([]string{"A"}), 10*time.Minute); err != nil {
// t.Fatal(err)
// }
// }

750
general_tests/session3_it_test.go
View File

@@ -21,402 +21,402 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"reflect"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "reflect"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// )
var (
ses3CfgDir string
ses3CfgPath string
ses3Cfg *config.CGRConfig
ses3RPC *rpc.Client
// var (
// ses3CfgDir string
// ses3CfgPath string
// ses3Cfg *config.CGRConfig
// ses3RPC *rpc.Client
ses3Tests = []func(t *testing.T){
testSes3ItLoadConfig,
testSes3ItResetDataDB,
testSes3ItResetStorDb,
testSes3ItStartEngine,
testSes3ItRPCConn,
testSes3ItLoadFromFolder,
testSes3ItProcessEvent,
testSes3ItThreshold1002After,
testSes3ItStatMetricsAfter,
testSes3ItProcessEvent,
testSes3ItThreshold1002After2,
testSes3ItStatMetricsAfter2,
// ses3Tests = []func(t *testing.T){
// testSes3ItLoadConfig,
// testSes3ItResetDataDB,
// testSes3ItResetStorDb,
// testSes3ItStartEngine,
// testSes3ItRPCConn,
// testSes3ItLoadFromFolder,
// testSes3ItProcessEvent,
// testSes3ItThreshold1002After,
// testSes3ItStatMetricsAfter,
// testSes3ItProcessEvent,
// testSes3ItThreshold1002After2,
// testSes3ItStatMetricsAfter2,
testSes3ItAddVoiceBalance,
testSes3ItTerminatWithoutInit,
testSes3ItBalance,
testSes3ItCDRs,
// testSes3ItAddVoiceBalance,
// testSes3ItTerminatWithoutInit,
// testSes3ItBalance,
// testSes3ItCDRs,
testSes3ItStopCgrEngine,
}
)
// testSes3ItStopCgrEngine,
// }
// )
func TestSes3ItSessions(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
ses3CfgDir = "sessions_internal"
case utils.MetaMySQL:
ses3CfgDir = "sessions_mysql"
case utils.MetaMongo:
ses3CfgDir = "sessions_mongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range ses3Tests {
t.Run(ses3CfgDir, stest)
}
}
// func TestSes3ItSessions(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// ses3CfgDir = "sessions_internal"
// case utils.MetaMySQL:
// ses3CfgDir = "sessions_mysql"
// case utils.MetaMongo:
// ses3CfgDir = "sessions_mongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range ses3Tests {
// t.Run(ses3CfgDir, stest)
// }
// }
func testSes3ItLoadConfig(t *testing.T) {
ses3CfgPath = path.Join(*dataDir, "conf", "samples", ses3CfgDir)
if ses3Cfg, err = config.NewCGRConfigFromPath(ses3CfgPath); err != nil {
t.Error(err)
}
}
// func testSes3ItLoadConfig(t *testing.T) {
// ses3CfgPath = path.Join(*dataDir, "conf", "samples", ses3CfgDir)
// if ses3Cfg, err = config.NewCGRConfigFromPath(ses3CfgPath); err != nil {
// t.Error(err)
// }
// }
func testSes3ItResetDataDB(t *testing.T) {
if err := engine.InitDataDB(ses3Cfg); err != nil {
t.Fatal(err)
}
}
// func testSes3ItResetDataDB(t *testing.T) {
// if err := engine.InitDataDB(ses3Cfg); err != nil {
// t.Fatal(err)
// }
// }
func testSes3ItResetStorDb(t *testing.T) {
if err := engine.InitStorDB(ses3Cfg); err != nil {
t.Fatal(err)
}
}
// func testSes3ItResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(ses3Cfg); err != nil {
// t.Fatal(err)
// }
// }
func testSes3ItStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(ses3CfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testSes3ItStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(ses3CfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testSes3ItRPCConn(t *testing.T) {
var err error
ses3RPC, err = newRPCClient(ses3Cfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testSes3ItRPCConn(t *testing.T) {
// var err error
// ses3RPC, err = newRPCClient(ses3Cfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testSes3ItLoadFromFolder(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")}
if err := ses3RPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
}
time.Sleep(100 * time.Millisecond)
}
// func testSes3ItLoadFromFolder(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")}
// if err := ses3RPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// }
// time.Sleep(100 * time.Millisecond)
// }
func testSes3ItProcessEvent(t *testing.T) {
initUsage := 5 * time.Minute
args := sessions.V1ProcessMessageArgs{
AllocateResources: true,
Debit: true,
GetAttributes: true,
ProcessThresholds: true,
ProcessStats: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSSv1ItProcessEvent",
Event: map[string]interface{}{
utils.CGRID: "c87609aa1cb6e9529ab1836cfeeebaab7aa7ebaf",
utils.Tenant: "cgrates.org",
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestSSv1It2",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1001",
utils.Destination: "1002",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: initUsage,
},
APIOpts: map[string]interface{}{
utils.OptsAPIKey: "ses12345",
},
},
}
var rply sessions.V1ProcessMessageReply
if err := ses3RPC.Call(utils.SessionSv1ProcessMessage,
args, &rply); err != nil {
t.Fatal(err)
}
if rply.MaxUsage == nil || *rply.MaxUsage != initUsage {
t.Errorf("Unexpected MaxUsage: %v", rply.MaxUsage)
}
if *rply.ResourceAllocation != "RES_ACNT_1001" {
t.Errorf("Unexpected ResourceAllocation: %s", *rply.ResourceAllocation)
}
eAttrs := &engine.AttrSProcessEventReply{
MatchedProfiles: []string{"cgrates.org:ATTR_ACNT_1001"},
AlteredFields: []string{"*req.OfficeGroup"},
// func testSes3ItProcessEvent(t *testing.T) {
// initUsage := 5 * time.Minute
// args := sessions.V1ProcessMessageArgs{
// AllocateResources: true,
// Debit: true,
// GetAttributes: true,
// ProcessThresholds: true,
// ProcessStats: true,
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSSv1ItProcessEvent",
// Event: map[string]interface{}{
// utils.CGRID: "c87609aa1cb6e9529ab1836cfeeebaab7aa7ebaf",
// utils.Tenant: "cgrates.org",
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestSSv1It2",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: "1001",
// utils.Destination: "1002",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: initUsage,
// },
// APIOpts: map[string]interface{}{
// utils.OptsAPIKey: "ses12345",
// },
// },
// }
// var rply sessions.V1ProcessMessageReply
// if err := ses3RPC.Call(utils.SessionSv1ProcessMessage,
// args, &rply); err != nil {
// t.Fatal(err)
// }
// if rply.MaxUsage == nil || *rply.MaxUsage != initUsage {
// t.Errorf("Unexpected MaxUsage: %v", rply.MaxUsage)
// }
// if *rply.ResourceAllocation != "RES_ACNT_1001" {
// t.Errorf("Unexpected ResourceAllocation: %s", *rply.ResourceAllocation)
// }
// eAttrs := &engine.AttrSProcessEventReply{
// MatchedProfiles: []string{"cgrates.org:ATTR_ACNT_1001"},
// AlteredFields: []string{"*req.OfficeGroup"},
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSSv1ItProcessEvent",
Event: map[string]interface{}{
utils.CGRID: "c87609aa1cb6e9529ab1836cfeeebaab7aa7ebaf",
utils.Tenant: "cgrates.org",
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.AccountField: "1001",
utils.Destination: "1002",
"OfficeGroup": "Marketing",
utils.OriginID: "TestSSv1It2",
utils.RequestType: utils.MetaPrepaid,
utils.SetupTime: "2018-01-07T17:00:00Z",
utils.AnswerTime: "2018-01-07T17:00:10Z",
utils.Usage: 300000000000.0,
},
APIOpts: map[string]interface{}{
utils.Subsys: utils.MetaSessionS,
utils.OptsAPIKey: "ses12345",
utils.MetaEventType: utils.StatUpdate,
},
},
}
if *encoding == utils.MetaGOB {
eAttrs.CGREvent.Event[utils.Usage] = 5 * time.Minute
eAttrs.CGREvent.Event[utils.SetupTime], _ = utils.IfaceAsTime("2018-01-07T17:00:00Z", "")
eAttrs.CGREvent.Event[utils.AnswerTime], _ = utils.IfaceAsTime("2018-01-07T17:00:10Z", "")
}
if !reflect.DeepEqual(*eAttrs, *rply.Attributes) {
t.Errorf("expecting: %+v, received: %+v",
utils.ToJSON(eAttrs), utils.ToJSON(rply.Attributes))
}
}
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSSv1ItProcessEvent",
// Event: map[string]interface{}{
// utils.CGRID: "c87609aa1cb6e9529ab1836cfeeebaab7aa7ebaf",
// utils.Tenant: "cgrates.org",
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.AccountField: "1001",
// utils.Destination: "1002",
// "OfficeGroup": "Marketing",
// utils.OriginID: "TestSSv1It2",
// utils.RequestType: utils.MetaPrepaid,
// utils.SetupTime: "2018-01-07T17:00:00Z",
// utils.AnswerTime: "2018-01-07T17:00:10Z",
// utils.Usage: 300000000000.0,
// },
// APIOpts: map[string]interface{}{
// utils.Subsys: utils.MetaSessionS,
// utils.OptsAPIKey: "ses12345",
// utils.MetaEventType: utils.StatUpdate,
// },
// },
// }
// if *encoding == utils.MetaGOB {
// eAttrs.CGREvent.Event[utils.Usage] = 5 * time.Minute
// eAttrs.CGREvent.Event[utils.SetupTime], _ = utils.IfaceAsTime("2018-01-07T17:00:00Z", "")
// eAttrs.CGREvent.Event[utils.AnswerTime], _ = utils.IfaceAsTime("2018-01-07T17:00:10Z", "")
// }
// if !reflect.DeepEqual(*eAttrs, *rply.Attributes) {
// t.Errorf("expecting: %+v, received: %+v",
// utils.ToJSON(eAttrs), utils.ToJSON(rply.Attributes))
// }
// }
func testSes3ItThreshold1002After(t *testing.T) {
var td engine.Threshold
eTd := engine.Threshold{Tenant: "cgrates.org", ID: "THD_ACNT_1001", Hits: 1}
if err := ses3RPC.Call(utils.ThresholdSv1GetThreshold,
&utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "THD_ACNT_1001"}}, &td); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(eTd.Tenant, td.Tenant) {
t.Errorf("expecting: %+v, received: %+v", eTd.Tenant, td.Tenant)
} else if !reflect.DeepEqual(eTd.ID, td.ID) {
t.Errorf("expecting: %+v, received: %+v", eTd.ID, td.ID)
} else if !reflect.DeepEqual(eTd.Hits, td.Hits) {
t.Errorf("expecting: %+v, received: %+v", eTd.Hits, td.Hits)
}
}
// func testSes3ItThreshold1002After(t *testing.T) {
// var td engine.Threshold
// eTd := engine.Threshold{Tenant: "cgrates.org", ID: "THD_ACNT_1001", Hits: 1}
// if err := ses3RPC.Call(utils.ThresholdSv1GetThreshold,
// &utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "THD_ACNT_1001"}}, &td); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(eTd.Tenant, td.Tenant) {
// t.Errorf("expecting: %+v, received: %+v", eTd.Tenant, td.Tenant)
// } else if !reflect.DeepEqual(eTd.ID, td.ID) {
// t.Errorf("expecting: %+v, received: %+v", eTd.ID, td.ID)
// } else if !reflect.DeepEqual(eTd.Hits, td.Hits) {
// t.Errorf("expecting: %+v, received: %+v", eTd.Hits, td.Hits)
// }
// }
func testSes3ItStatMetricsAfter(t *testing.T) {
var metrics map[string]string
statMetrics := map[string]string{
utils.MetaACD: "5m0s",
utils.MetaASR: "100%",
utils.MetaTCD: "5m0s",
}
// func testSes3ItStatMetricsAfter(t *testing.T) {
// var metrics map[string]string
// statMetrics := map[string]string{
// utils.MetaACD: "5m0s",
// utils.MetaASR: "100%",
// utils.MetaTCD: "5m0s",
// }
if err := ses3RPC.Call(utils.StatSv1GetQueueStringMetrics,
&utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "Stat_1"}}, &metrics); err != nil {
t.Error(err)
}
if !reflect.DeepEqual(statMetrics, metrics) {
t.Errorf("expecting: %+v, received reply: %s", statMetrics, metrics)
}
}
// if err := ses3RPC.Call(utils.StatSv1GetQueueStringMetrics,
// &utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "Stat_1"}}, &metrics); err != nil {
// t.Error(err)
// }
// if !reflect.DeepEqual(statMetrics, metrics) {
// t.Errorf("expecting: %+v, received reply: %s", statMetrics, metrics)
// }
// }
func testSes3ItThreshold1002After2(t *testing.T) {
var td engine.Threshold
eTd := engine.Threshold{Tenant: "cgrates.org", ID: "THD_ACNT_1001", Hits: 2}
if err := ses3RPC.Call(utils.ThresholdSv1GetThreshold,
&utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "THD_ACNT_1001"}}, &td); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(eTd.Tenant, td.Tenant) {
t.Errorf("expecting: %+v, received: %+v", eTd.Tenant, td.Tenant)
} else if !reflect.DeepEqual(eTd.ID, td.ID) {
t.Errorf("expecting: %+v, received: %+v", eTd.ID, td.ID)
} else if !reflect.DeepEqual(eTd.Hits, td.Hits) {
t.Errorf("expecting: %+v, received: %+v", eTd.Hits, td.Hits)
}
}
// func testSes3ItThreshold1002After2(t *testing.T) {
// var td engine.Threshold
// eTd := engine.Threshold{Tenant: "cgrates.org", ID: "THD_ACNT_1001", Hits: 2}
// if err := ses3RPC.Call(utils.ThresholdSv1GetThreshold,
// &utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "THD_ACNT_1001"}}, &td); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(eTd.Tenant, td.Tenant) {
// t.Errorf("expecting: %+v, received: %+v", eTd.Tenant, td.Tenant)
// } else if !reflect.DeepEqual(eTd.ID, td.ID) {
// t.Errorf("expecting: %+v, received: %+v", eTd.ID, td.ID)
// } else if !reflect.DeepEqual(eTd.Hits, td.Hits) {
// t.Errorf("expecting: %+v, received: %+v", eTd.Hits, td.Hits)
// }
// }
func testSes3ItStatMetricsAfter2(t *testing.T) {
var metrics map[string]string
statMetrics := map[string]string{
utils.MetaACD: "5m0s",
utils.MetaASR: "100%",
utils.MetaTCD: "10m0s",
}
// func testSes3ItStatMetricsAfter2(t *testing.T) {
// var metrics map[string]string
// statMetrics := map[string]string{
// utils.MetaACD: "5m0s",
// utils.MetaASR: "100%",
// utils.MetaTCD: "10m0s",
// }
if err := ses3RPC.Call(utils.StatSv1GetQueueStringMetrics,
&utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "Stat_1"}}, &metrics); err != nil {
t.Error(err)
}
if !reflect.DeepEqual(statMetrics, metrics) {
t.Errorf("expecting: %+v, received reply: %s", statMetrics, metrics)
}
}
// if err := ses3RPC.Call(utils.StatSv1GetQueueStringMetrics,
// &utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "Stat_1"}}, &metrics); err != nil {
// t.Error(err)
// }
// if !reflect.DeepEqual(statMetrics, metrics) {
// t.Errorf("expecting: %+v, received reply: %s", statMetrics, metrics)
// }
// }
func testSes3ItAddVoiceBalance(t *testing.T) {
attrSetBalance := utils.AttrSetBalance{
Tenant: "cgrates.org",
Account: "1002",
BalanceType: utils.MetaVoice,
Value: 5 * float64(time.Second),
Balance: map[string]interface{}{
utils.ID: "TestDynamicDebitBalance",
utils.RatingSubject: "*zero5ms",
},
}
var reply string
if err := ses3RPC.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Received: %s", reply)
}
var acnt *engine.Account
attrs := &utils.AttrGetAccount{
Tenant: "cgrates.org",
Account: "1002",
}
if err := ses3RPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error(err)
} else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply != float64(5*time.Second) {
t.Errorf("Expecting: %v, received: %v",
float64(5*time.Second), rply)
}
}
// func testSes3ItAddVoiceBalance(t *testing.T) {
// attrSetBalance := utils.AttrSetBalance{
// Tenant: "cgrates.org",
// Account: "1002",
// BalanceType: utils.MetaVoice,
// Value: 5 * float64(time.Second),
// Balance: map[string]interface{}{
// utils.ID: "TestDynamicDebitBalance",
// utils.RatingSubject: "*zero5ms",
// },
// }
// var reply string
// if err := ses3RPC.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Received: %s", reply)
// }
// var acnt *engine.Account
// attrs := &utils.AttrGetAccount{
// Tenant: "cgrates.org",
// Account: "1002",
// }
// if err := ses3RPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error(err)
// } else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply != float64(5*time.Second) {
// t.Errorf("Expecting: %v, received: %v",
// float64(5*time.Second), rply)
// }
// }
func testSes3ItTerminatWithoutInit(t *testing.T) {
go func() { // used in a gorutine to not block the test
// because it needs to call initSession when the call for Teminate is still active
args := &sessions.V1TerminateSessionArgs{
TerminateSession: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSesItUpdateSession",
Event: map[string]interface{}{
utils.Tenant: "cgrates.org",
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestTerminate",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1002",
utils.Subject: "1001",
utils.Destination: "1001",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 2 * time.Second,
},
},
}
var rply string
if err := ses3RPC.Call(utils.SessionSv1TerminateSession,
args, &rply); err != nil {
t.Error(err)
}
if rply != utils.OK {
t.Errorf("Unexpected reply: %s", rply)
}
}()
// func testSes3ItTerminatWithoutInit(t *testing.T) {
// go func() { // used in a gorutine to not block the test
// // because it needs to call initSession when the call for Teminate is still active
// args := &sessions.V1TerminateSessionArgs{
// TerminateSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSesItUpdateSession",
// Event: map[string]interface{}{
// utils.Tenant: "cgrates.org",
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestTerminate",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: "1002",
// utils.Subject: "1001",
// utils.Destination: "1001",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 2 * time.Second,
// },
// },
// }
// var rply string
// if err := ses3RPC.Call(utils.SessionSv1TerminateSession,
// args, &rply); err != nil {
// t.Error(err)
// }
// if rply != utils.OK {
// t.Errorf("Unexpected reply: %s", rply)
// }
// }()
time.Sleep(3 * time.Millisecond)
args1 := &sessions.V1InitSessionArgs{
InitSession: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSesItInitiateSession",
Event: map[string]interface{}{
utils.Tenant: "cgrates.org",
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestTerminate",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1002",
utils.Subject: "1001",
utils.Destination: "1001",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 5 * time.Second,
},
},
}
var rply1 sessions.V1InitSessionReply
if err := ses3RPC.Call(utils.SessionSv1InitiateSession,
args1, &rply1); err != nil {
t.Error(err)
return
} else if rply1.MaxUsage != nil && *rply1.MaxUsage != 0 {
t.Errorf("Unexpected MaxUsage: %v", rply1.MaxUsage)
}
time.Sleep(5 * time.Millisecond)
aSessions := make([]*sessions.ExternalSession, 0)
if err := ses3RPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
func testSes3ItBalance(t *testing.T) {
time.Sleep(10 * time.Millisecond)
var acnt engine.Account
attrs := &utils.AttrGetAccount{
Tenant: "cgrates.org",
Account: "1002",
}
if err := ses3RPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error(err)
} else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply != float64(3*time.Second) {
t.Errorf("Expecting: %v, received: %v",
3*time.Second, rply)
}
}
// time.Sleep(3 * time.Millisecond)
// args1 := &sessions.V1InitSessionArgs{
// InitSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSesItInitiateSession",
// Event: map[string]interface{}{
// utils.Tenant: "cgrates.org",
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestTerminate",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: "1002",
// utils.Subject: "1001",
// utils.Destination: "1001",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 5 * time.Second,
// },
// },
// }
// var rply1 sessions.V1InitSessionReply
// if err := ses3RPC.Call(utils.SessionSv1InitiateSession,
// args1, &rply1); err != nil {
// t.Error(err)
// return
// } else if rply1.MaxUsage != nil && *rply1.MaxUsage != 0 {
// t.Errorf("Unexpected MaxUsage: %v", rply1.MaxUsage)
// }
// time.Sleep(5 * time.Millisecond)
// aSessions := make([]*sessions.ExternalSession, 0)
// if err := ses3RPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// }
// func testSes3ItBalance(t *testing.T) {
// time.Sleep(10 * time.Millisecond)
// var acnt engine.Account
// attrs := &utils.AttrGetAccount{
// Tenant: "cgrates.org",
// Account: "1002",
// }
// if err := ses3RPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error(err)
// } else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply != float64(3*time.Second) {
// t.Errorf("Expecting: %v, received: %v",
// 3*time.Second, rply)
// }
// }
func testSes3ItCDRs(t *testing.T) {
var reply string
if err := ses3RPC.Call(utils.SessionSv1ProcessCDR, &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSesItProccesCDR",
Event: map[string]interface{}{
utils.Tenant: "cgrates.org",
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestTerminate",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1002",
utils.Subject: "1001",
utils.Destination: "1001",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 2 * time.Second,
},
}, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Received reply: %s", reply)
}
time.Sleep(20 * time.Millisecond)
var cdrs []*engine.ExternalCDR
req := utils.RPCCDRsFilter{RunIDs: []string{"CustomerCharges"},
Accounts: []string{"1002"}}
if err := ses3RPC.Call(utils.APIerSv2GetCDRs, &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 != "2s" {
t.Errorf("Unexpected CDR Usage received, cdr: %v %+v ", cdrs[0].Usage, cdrs[0])
}
}
func testSes3ItStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSes3ItCDRs(t *testing.T) {
// var reply string
// if err := ses3RPC.Call(utils.SessionSv1ProcessCDR, &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSesItProccesCDR",
// Event: map[string]interface{}{
// utils.Tenant: "cgrates.org",
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestTerminate",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: "1002",
// utils.Subject: "1001",
// utils.Destination: "1001",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 2 * time.Second,
// },
// }, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Received reply: %s", reply)
// }
// time.Sleep(20 * time.Millisecond)
// var cdrs []*engine.ExternalCDR
// req := utils.RPCCDRsFilter{RunIDs: []string{"CustomerCharges"},
// Accounts: []string{"1002"}}
// if err := ses3RPC.Call(utils.APIerSv2GetCDRs, &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 != "2s" {
// t.Errorf("Unexpected CDR Usage received, cdr: %v %+v ", cdrs[0].Usage, cdrs[0])
// }
// }
// func testSes3ItStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

264
general_tests/session4_it_test.go
View File

@@ -21,152 +21,152 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
ses4CfgDir string
ses4CfgPath string
ses4Cfg *config.CGRConfig
ses4RPC *rpc.Client
// var (
// ses4CfgDir string
// ses4CfgPath string
// ses4Cfg *config.CGRConfig
// ses4RPC *rpc.Client
ses4Tests = []func(t *testing.T){
testSes4ItLoadConfig,
testSes4ItResetDataDB,
testSes4ItResetStorDb,
testSes4ItStartEngine,
testSes4ItRPCConn,
testSes4ItLoadFromFolder,
// ses4Tests = []func(t *testing.T){
// testSes4ItLoadConfig,
// testSes4ItResetDataDB,
// testSes4ItResetStorDb,
// testSes4ItStartEngine,
// testSes4ItRPCConn,
// testSes4ItLoadFromFolder,
testSes4SetAccount,
testSes4CDRsProcessCDR,
// testSes4SetAccount,
// testSes4CDRsProcessCDR,
testSes4ItStopCgrEngine,
}
)
// testSes4ItStopCgrEngine,
// }
// )
func TestSes4ItSessions(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
ses4CfgDir = "sessions_internal"
case utils.MetaMySQL:
ses4CfgDir = "sessions_mysql"
case utils.MetaMongo:
ses4CfgDir = "sessions_mongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range ses4Tests {
t.Run(ses4CfgDir, stest)
}
}
// func TestSes4ItSessions(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// ses4CfgDir = "sessions_internal"
// case utils.MetaMySQL:
// ses4CfgDir = "sessions_mysql"
// case utils.MetaMongo:
// ses4CfgDir = "sessions_mongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range ses4Tests {
// t.Run(ses4CfgDir, stest)
// }
// }
func testSes4ItLoadConfig(t *testing.T) {
ses4CfgPath = path.Join(*dataDir, "conf", "samples", ses4CfgDir)
if ses4Cfg, err = config.NewCGRConfigFromPath(ses4CfgPath); err != nil {
t.Error(err)
}
}
// func testSes4ItLoadConfig(t *testing.T) {
// ses4CfgPath = path.Join(*dataDir, "conf", "samples", ses4CfgDir)
// if ses4Cfg, err = config.NewCGRConfigFromPath(ses4CfgPath); err != nil {
// t.Error(err)
// }
// }
func testSes4ItResetDataDB(t *testing.T) {
if err := engine.InitDataDB(ses4Cfg); err != nil {
t.Fatal(err)
}
}
// func testSes4ItResetDataDB(t *testing.T) {
// if err := engine.InitDataDB(ses4Cfg); err != nil {
// t.Fatal(err)
// }
// }
func testSes4ItResetStorDb(t *testing.T) {
if err := engine.InitStorDB(ses4Cfg); err != nil {
t.Fatal(err)
}
}
// func testSes4ItResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(ses4Cfg); err != nil {
// t.Fatal(err)
// }
// }
func testSes4ItStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(ses4CfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testSes4ItStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(ses4CfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testSes4ItRPCConn(t *testing.T) {
var err error
ses4RPC, err = newRPCClient(ses4Cfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testSes4ItRPCConn(t *testing.T) {
// var err error
// ses4RPC, err = newRPCClient(ses4Cfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testSes4ItLoadFromFolder(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")}
if err := ses4RPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
}
time.Sleep(100 * time.Millisecond)
}
// func testSes4ItLoadFromFolder(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")}
// if err := ses4RPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// }
// time.Sleep(100 * time.Millisecond)
// }
func testSes4SetAccount(t *testing.T) {
var reply string
attrs := &utils.AttrSetAccount{Tenant: "cgrates.org", Account: "dan7"}
if err := ses4RPC.Call(utils.APIerSv1SetAccount, attrs, &reply); err != nil {
t.Error("Got error on APIerSv1.SetAccount: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv1.SetAccount received: %s", reply)
}
}
// func testSes4SetAccount(t *testing.T) {
// var reply string
// attrs := &utils.AttrSetAccount{Tenant: "cgrates.org", Account: "dan7"}
// if err := ses4RPC.Call(utils.APIerSv1SetAccount, attrs, &reply); err != nil {
// t.Error("Got error on APIerSv1.SetAccount: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv1.SetAccount received: %s", reply)
// }
// }
func testSes4CDRsProcessCDR(t *testing.T) {
// proccess twice the postpaid event that doesn't cost
// this reproduce the issue #2123:
// rerate a free postpaid event in the CDRServer
// will make the BalanceInfo nil and result in a panic
args := &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
utils.OriginID: "testV2CDRsProcessCDR1",
utils.OriginHost: "192.168.1.1",
utils.Source: "testV2CDRsProcessCDR",
utils.RequestType: utils.MetaPostpaid,
utils.Category: "free",
utils.AccountField: "dan7",
utils.Subject: "RP_FREE",
utils.Destination: "0775692",
utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
utils.Usage: time.Minute,
},
APIOpts: map[string]interface{}{
// utils.MetaRALs:true,
utils.OptsCDRsStore: true,
utils.OptsRouteS: false,
utils.OptsCDRsRerate: true,
},
// Flags: []string{utils.MetaRALs, utils.MetaStore, "*routes:false", utils.MetaRerate},
}
// func testSes4CDRsProcessCDR(t *testing.T) {
// // proccess twice the postpaid event that doesn't cost
// // this reproduce the issue #2123:
// // rerate a free postpaid event in the CDRServer
// // will make the BalanceInfo nil and result in a panic
// args := &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// utils.OriginID: "testV2CDRsProcessCDR1",
// utils.OriginHost: "192.168.1.1",
// utils.Source: "testV2CDRsProcessCDR",
// utils.RequestType: utils.MetaPostpaid,
// utils.Category: "free",
// utils.AccountField: "dan7",
// utils.Subject: "RP_FREE",
// utils.Destination: "0775692",
// utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
// utils.Usage: time.Minute,
// },
// APIOpts: map[string]interface{}{
// // utils.MetaRALs:true,
// utils.OptsCDRsStore: true,
// utils.OptsRouteS: false,
// utils.OptsCDRsRerate: true,
// },
// // Flags: []string{utils.MetaRALs, utils.MetaStore, "*routes:false", utils.MetaRerate},
// }
var reply string
if err := ses4RPC.Call(utils.CDRsV1ProcessEvent, args, &reply); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if reply != utils.OK {
t.Error("Unexpected reply received: ", reply)
}
// var reply string
// if err := ses4RPC.Call(utils.CDRsV1ProcessEvent, args, &reply); err != nil {
// t.Error("Unexpected error: ", err.Error())
// } else if reply != utils.OK {
// t.Error("Unexpected reply received: ", reply)
// }
if err := ses4RPC.Call(utils.CDRsV1ProcessEvent, args, &reply); err != nil {
t.Error("Unexpected error: ", err.Error())
} else if reply != utils.OK {
t.Error("Unexpected reply received: ", reply)
}
}
// if err := ses4RPC.Call(utils.CDRsV1ProcessEvent, args, &reply); err != nil {
// t.Error("Unexpected error: ", err.Error())
// } else if reply != utils.OK {
// t.Error("Unexpected reply received: ", reply)
// }
// }
func testSes4ItStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSes4ItStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

562
general_tests/session_graceful_shutdown_it_test.go
View File

@@ -20,307 +20,307 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"net/rpc"
"os/exec"
"path"
"reflect"
"syscall"
"testing"
"time"
// import (
// "net/rpc"
// "os/exec"
// "path"
// "reflect"
// "syscall"
// "testing"
// "time"
"github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/utils"
// )
var (
smgRplcCfgPath1, smgRplcCfgPath2 string
smgRplcCfgDIR1, smgRplcCfgDIR2 string
smgRplCfg1, smgRplCfg2 *config.CGRConfig
smgRplcRPC1, smgRplcRPC2 *rpc.Client
testEngine1, testEngine2 *exec.Cmd
sTestsSession1 = []func(t *testing.T){
testSessionSRplcInitCfg,
testSessionSRplcResetDB,
testSessionSRplcStartEngine,
testSessionSRplcApierRpcConn,
testSessionSRplcApierGetActiveSessionsNotFound,
testSessionSRplcApierSetChargerS,
testSessionSRplcApierGetInitateSessions,
testSessionSRplcApierGetActiveSessions,
testSessionSRplcApierGetPassiveSessions,
testSessionSRplcApierStopSession2,
testSessionSRplcApierGetPassiveSessionsAfterStop,
testSessionSRplcStopCgrEngine,
}
)
// var (
// smgRplcCfgPath1, smgRplcCfgPath2 string
// smgRplcCfgDIR1, smgRplcCfgDIR2 string
// smgRplCfg1, smgRplCfg2 *config.CGRConfig
// smgRplcRPC1, smgRplcRPC2 *rpc.Client
// testEngine1, testEngine2 *exec.Cmd
// sTestsSession1 = []func(t *testing.T){
// testSessionSRplcInitCfg,
// testSessionSRplcResetDB,
// testSessionSRplcStartEngine,
// testSessionSRplcApierRpcConn,
// testSessionSRplcApierGetActiveSessionsNotFound,
// testSessionSRplcApierSetChargerS,
// testSessionSRplcApierGetInitateSessions,
// testSessionSRplcApierGetActiveSessions,
// testSessionSRplcApierGetPassiveSessions,
// testSessionSRplcApierStopSession2,
// testSessionSRplcApierGetPassiveSessionsAfterStop,
// testSessionSRplcStopCgrEngine,
// }
// )
func TestSessionSRplcGracefulShutdown(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
smgRplcCfgDIR1 = "rplcTestGracefulShutdown1_internal"
smgRplcCfgDIR2 = "rplcTestGracefulShutdown2_internal"
case utils.MetaMySQL:
smgRplcCfgDIR1 = "rplcTestGracefulShutdown1_mysql"
smgRplcCfgDIR2 = "rplcTestGracefulShutdown2_mysql"
case utils.MetaMongo:
smgRplcCfgDIR1 = "rplcTestGracefulShutdown1_mongo"
smgRplcCfgDIR2 = "rplcTestGracefulShutdown2_mongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
// func TestSessionSRplcGracefulShutdown(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// smgRplcCfgDIR1 = "rplcTestGracefulShutdown1_internal"
// smgRplcCfgDIR2 = "rplcTestGracefulShutdown2_internal"
// case utils.MetaMySQL:
// smgRplcCfgDIR1 = "rplcTestGracefulShutdown1_mysql"
// smgRplcCfgDIR2 = "rplcTestGracefulShutdown2_mysql"
// case utils.MetaMongo:
// smgRplcCfgDIR1 = "rplcTestGracefulShutdown1_mongo"
// smgRplcCfgDIR2 = "rplcTestGracefulShutdown2_mongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
for _, stest1 := range sTestsSession1 {
t.Run(*dbType, stest1)
}
}
// for _, stest1 := range sTestsSession1 {
// t.Run(*dbType, stest1)
// }
// }
//Init Config
func testSessionSRplcInitCfg(t *testing.T) {
smgRplcCfgPath1 = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcCfgDIR1)
if smgRplCfg1, err = config.NewCGRConfigFromPath(smgRplcCfgPath1); err != nil {
t.Fatal(err)
}
smgRplcCfgPath2 = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcCfgDIR2)
if smgRplCfg2, err = config.NewCGRConfigFromPath(smgRplcCfgPath2); err != nil {
t.Fatal(err)
}
}
// //Init Config
// func testSessionSRplcInitCfg(t *testing.T) {
// smgRplcCfgPath1 = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcCfgDIR1)
// if smgRplCfg1, err = config.NewCGRConfigFromPath(smgRplcCfgPath1); err != nil {
// t.Fatal(err)
// }
// smgRplcCfgPath2 = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcCfgDIR2)
// if smgRplCfg2, err = config.NewCGRConfigFromPath(smgRplcCfgPath2); err != nil {
// t.Fatal(err)
// }
// }
// Remove data in both rating and accounting db
func testSessionSRplcResetDB(t *testing.T) {
if err := engine.InitDataDB(smgRplCfg1); err != nil {
t.Fatal(err)
}
if err := engine.InitStorDB(smgRplCfg1); err != nil {
t.Fatal(err)
}
}
// // Remove data in both rating and accounting db
// func testSessionSRplcResetDB(t *testing.T) {
// if err := engine.InitDataDB(smgRplCfg1); err != nil {
// t.Fatal(err)
// }
// if err := engine.InitStorDB(smgRplCfg1); err != nil {
// t.Fatal(err)
// }
// }
// Start CGR Engine
func testSessionSRplcStartEngine(t *testing.T) {
if _, err = engine.StopStartEngine(smgRplcCfgPath1, *waitRater); err != nil {
t.Fatal(err)
}
if testEngine1, err = engine.StartEngine(smgRplcCfgPath2, *waitRater); err != nil {
t.Fatal(err)
}
// // Start CGR Engine
// func testSessionSRplcStartEngine(t *testing.T) {
// if _, err = engine.StopStartEngine(smgRplcCfgPath1, *waitRater); err != nil {
// t.Fatal(err)
// }
// if testEngine1, err = engine.StartEngine(smgRplcCfgPath2, *waitRater); err != nil {
// t.Fatal(err)
// }
}
// }
// Connect rpc client to rater
func testSessionSRplcApierRpcConn(t *testing.T) {
if smgRplcRPC1, err = newRPCClient(smgRplCfg1.ListenCfg()); err != nil {
t.Fatal(err)
}
if smgRplcRPC2, err = newRPCClient(smgRplCfg2.ListenCfg()); err != nil {
t.Fatal(err)
}
}
// // Connect rpc client to rater
// func testSessionSRplcApierRpcConn(t *testing.T) {
// if smgRplcRPC1, err = newRPCClient(smgRplCfg1.ListenCfg()); err != nil {
// t.Fatal(err)
// }
// if smgRplcRPC2, err = newRPCClient(smgRplCfg2.ListenCfg()); err != nil {
// t.Fatal(err)
// }
// }
func testSessionSRplcApierGetActiveSessionsNotFound(t *testing.T) {
aSessions1 := make([]*sessions.ExternalSession, 0)
expected := "NOT_FOUND"
if err := smgRplcRPC1.Call(utils.SessionSv1GetActiveSessions, &utils.SessionFilter{}, &aSessions1); err == nil || err.Error() != expected {
t.Error(err)
}
aSessions2 := make([]*sessions.ExternalSession, 0)
if err := smgRplcRPC2.Call(utils.SessionSv1GetActiveSessions, &utils.SessionFilter{}, &aSessions2); err == nil || err.Error() != expected {
t.Error(err)
}
}
// func testSessionSRplcApierGetActiveSessionsNotFound(t *testing.T) {
// aSessions1 := make([]*sessions.ExternalSession, 0)
// expected := "NOT_FOUND"
// if err := smgRplcRPC1.Call(utils.SessionSv1GetActiveSessions, &utils.SessionFilter{}, &aSessions1); err == nil || err.Error() != expected {
// t.Error(err)
// }
// aSessions2 := make([]*sessions.ExternalSession, 0)
// if err := smgRplcRPC2.Call(utils.SessionSv1GetActiveSessions, &utils.SessionFilter{}, &aSessions2); err == nil || err.Error() != expected {
// t.Error(err)
// }
// }
func testSessionSRplcApierSetChargerS(t *testing.T) {
chargerProfile1 := &v1.ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "Default",
RunID: utils.MetaDefault,
AttributeIDs: []string{"*none"},
Weight: 20,
},
}
var result1 string
if err := smgRplcRPC1.Call(utils.AdminSv1SetChargerProfile, chargerProfile1, &result1); err != nil {
t.Error(err)
} else if result1 != utils.OK {
t.Error("Unexpected reply returned", result1)
}
// func testSessionSRplcApierSetChargerS(t *testing.T) {
// chargerProfile1 := &v1.ChargerWithAPIOpts{
// ChargerProfile: &engine.ChargerProfile{
// Tenant: "cgrates.org",
// ID: "Default",
// RunID: utils.MetaDefault,
// AttributeIDs: []string{"*none"},
// Weight: 20,
// },
// }
// var result1 string
// if err := smgRplcRPC1.Call(utils.AdminSv1SetChargerProfile, chargerProfile1, &result1); err != nil {
// t.Error(err)
// } else if result1 != utils.OK {
// t.Error("Unexpected reply returned", result1)
// }
chargerProfile2 := &v1.ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "Default",
RunID: utils.MetaDefault,
AttributeIDs: []string{"*none"},
Weight: 20,
},
}
var result2 string
if err := smgRplcRPC2.Call(utils.AdminSv1SetChargerProfile, chargerProfile2, &result2); err != nil {
t.Error(err)
} else if result2 != utils.OK {
t.Error("Unexpected reply returned", result2)
}
}
// chargerProfile2 := &v1.ChargerWithAPIOpts{
// ChargerProfile: &engine.ChargerProfile{
// Tenant: "cgrates.org",
// ID: "Default",
// RunID: utils.MetaDefault,
// AttributeIDs: []string{"*none"},
// Weight: 20,
// },
// }
// var result2 string
// if err := smgRplcRPC2.Call(utils.AdminSv1SetChargerProfile, chargerProfile2, &result2); err != nil {
// t.Error(err)
// } else if result2 != utils.OK {
// t.Error("Unexpected reply returned", result2)
// }
// }
func testSessionSRplcApierGetInitateSessions(t *testing.T) {
args := &sessions.V1InitSessionArgs{
InitSession: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSSv1ItInitiateSession",
Event: map[string]interface{}{
utils.Tenant: "cgrates.org",
utils.RequestType: utils.MetaNone,
utils.CGRID: "testSessionRplCGRID",
utils.OriginID: "testSessionRplORIGINID",
},
},
}
var rply sessions.V1InitSessionReply
if err := smgRplcRPC2.Call(utils.SessionSv1InitiateSession,
args, &rply); err != nil {
t.Error(err)
}
}
// func testSessionSRplcApierGetInitateSessions(t *testing.T) {
// args := &sessions.V1InitSessionArgs{
// InitSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSSv1ItInitiateSession",
// Event: map[string]interface{}{
// utils.Tenant: "cgrates.org",
// utils.RequestType: utils.MetaNone,
// utils.CGRID: "testSessionRplCGRID",
// utils.OriginID: "testSessionRplORIGINID",
// },
// },
// }
// var rply sessions.V1InitSessionReply
// if err := smgRplcRPC2.Call(utils.SessionSv1InitiateSession,
// args, &rply); err != nil {
// t.Error(err)
// }
// }
func testSessionSRplcApierGetActiveSessions(t *testing.T) {
expected := []*sessions.ExternalSession{
{
CGRID: "testSessionRplCGRID",
RunID: "*default",
ToR: "",
OriginID: "testSessionRplORIGINID",
OriginHost: "",
Source: "SessionS_",
RequestType: utils.MetaNone,
Tenant: "cgrates.org",
Category: "",
Account: "",
Subject: "",
Destination: "",
SetupTime: time.Time{},
AnswerTime: time.Time{},
Usage: 0,
ExtraFields: map[string]string{},
NodeID: "MasterReplication",
LoopIndex: 0,
DurationIndex: 0,
MaxRate: 0,
MaxRateUnit: 0,
MaxCostSoFar: 0,
DebitInterval: 0,
NextAutoDebit: time.Time{},
},
}
aSessions2 := make([]*sessions.ExternalSession, 0)
if err := smgRplcRPC2.Call(utils.SessionSv1GetActiveSessions, &utils.SessionFilter{}, &aSessions2); err != nil {
t.Error(err)
}
if !reflect.DeepEqual(&aSessions2, &expected) {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(&aSessions2), utils.ToJSON(&expected))
// func testSessionSRplcApierGetActiveSessions(t *testing.T) {
// expected := []*sessions.ExternalSession{
// {
// CGRID: "testSessionRplCGRID",
// RunID: "*default",
// ToR: "",
// OriginID: "testSessionRplORIGINID",
// OriginHost: "",
// Source: "SessionS_",
// RequestType: utils.MetaNone,
// Tenant: "cgrates.org",
// Category: "",
// Account: "",
// Subject: "",
// Destination: "",
// SetupTime: time.Time{},
// AnswerTime: time.Time{},
// Usage: 0,
// ExtraFields: map[string]string{},
// NodeID: "MasterReplication",
// LoopIndex: 0,
// DurationIndex: 0,
// MaxRate: 0,
// MaxRateUnit: 0,
// MaxCostSoFar: 0,
// DebitInterval: 0,
// NextAutoDebit: time.Time{},
// },
// }
// aSessions2 := make([]*sessions.ExternalSession, 0)
// if err := smgRplcRPC2.Call(utils.SessionSv1GetActiveSessions, &utils.SessionFilter{}, &aSessions2); err != nil {
// t.Error(err)
// }
// if !reflect.DeepEqual(&aSessions2, &expected) {
// t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(&aSessions2), utils.ToJSON(&expected))
}
}
// }
// }
func testSessionSRplcApierGetPassiveSessions(t *testing.T) {
expected := []*sessions.ExternalSession{
{
CGRID: "testSessionRplCGRID",
RunID: "*default",
ToR: "",
OriginID: "testSessionRplORIGINID",
OriginHost: "",
Source: "SessionS_",
RequestType: utils.MetaNone,
Tenant: "cgrates.org",
Category: "",
Account: "",
Subject: "",
Destination: "",
SetupTime: time.Time{},
AnswerTime: time.Time{},
Usage: 0,
ExtraFields: map[string]string{},
NodeID: "MasterReplication",
LoopIndex: 0,
DurationIndex: 0,
MaxRate: 0,
MaxRateUnit: 0,
MaxCostSoFar: 0,
DebitInterval: 0,
NextAutoDebit: time.Time{},
},
}
aSessions2 := make([]*sessions.ExternalSession, 0)
if err := smgRplcRPC1.Call(utils.SessionSv1GetPassiveSessions, &utils.SessionFilter{}, &aSessions2); err != nil {
t.Error(err)
}
if !reflect.DeepEqual(&aSessions2, &expected) {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(&aSessions2), utils.ToJSON(&expected))
// func testSessionSRplcApierGetPassiveSessions(t *testing.T) {
// expected := []*sessions.ExternalSession{
// {
// CGRID: "testSessionRplCGRID",
// RunID: "*default",
// ToR: "",
// OriginID: "testSessionRplORIGINID",
// OriginHost: "",
// Source: "SessionS_",
// RequestType: utils.MetaNone,
// Tenant: "cgrates.org",
// Category: "",
// Account: "",
// Subject: "",
// Destination: "",
// SetupTime: time.Time{},
// AnswerTime: time.Time{},
// Usage: 0,
// ExtraFields: map[string]string{},
// NodeID: "MasterReplication",
// LoopIndex: 0,
// DurationIndex: 0,
// MaxRate: 0,
// MaxRateUnit: 0,
// MaxCostSoFar: 0,
// DebitInterval: 0,
// NextAutoDebit: time.Time{},
// },
// }
// aSessions2 := make([]*sessions.ExternalSession, 0)
// if err := smgRplcRPC1.Call(utils.SessionSv1GetPassiveSessions, &utils.SessionFilter{}, &aSessions2); err != nil {
// t.Error(err)
// }
// if !reflect.DeepEqual(&aSessions2, &expected) {
// t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(&aSessions2), utils.ToJSON(&expected))
}
}
// }
// }
func testSessionSRplcApierStopSession2(t *testing.T) {
err := testEngine1.Process.Signal(syscall.SIGTERM)
if err != nil {
t.Error(err)
}
err = testEngine1.Wait()
if err != nil {
t.Error(err)
}
}
// func testSessionSRplcApierStopSession2(t *testing.T) {
// err := testEngine1.Process.Signal(syscall.SIGTERM)
// if err != nil {
// t.Error(err)
// }
// err = testEngine1.Wait()
// if err != nil {
// t.Error(err)
// }
// }
func testSessionSRplcApierGetPassiveSessionsAfterStop(t *testing.T) {
expected := []*sessions.ExternalSession{
{
CGRID: "testSessionRplCGRID",
RunID: "*default",
ToR: "",
OriginID: "testSessionRplORIGINID",
OriginHost: "",
Source: "SessionS_",
RequestType: utils.MetaNone,
Tenant: "cgrates.org",
Category: "",
Account: "",
Subject: "",
Destination: "",
SetupTime: time.Time{},
AnswerTime: time.Time{},
Usage: 0,
ExtraFields: map[string]string{},
NodeID: "MasterReplication",
LoopIndex: 0,
DurationIndex: 0,
MaxRate: 0,
MaxRateUnit: 0,
MaxCostSoFar: 0,
DebitInterval: 0,
NextAutoDebit: time.Time{},
},
}
aSessions2 := make([]*sessions.ExternalSession, 0)
if err := smgRplcRPC1.Call(utils.SessionSv1GetPassiveSessions, &utils.SessionFilter{}, &aSessions2); err != nil {
t.Error(err)
}
if !reflect.DeepEqual(&aSessions2, &expected) {
t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(&aSessions2), utils.ToJSON(&expected))
// func testSessionSRplcApierGetPassiveSessionsAfterStop(t *testing.T) {
// expected := []*sessions.ExternalSession{
// {
// CGRID: "testSessionRplCGRID",
// RunID: "*default",
// ToR: "",
// OriginID: "testSessionRplORIGINID",
// OriginHost: "",
// Source: "SessionS_",
// RequestType: utils.MetaNone,
// Tenant: "cgrates.org",
// Category: "",
// Account: "",
// Subject: "",
// Destination: "",
// SetupTime: time.Time{},
// AnswerTime: time.Time{},
// Usage: 0,
// ExtraFields: map[string]string{},
// NodeID: "MasterReplication",
// LoopIndex: 0,
// DurationIndex: 0,
// MaxRate: 0,
// MaxRateUnit: 0,
// MaxCostSoFar: 0,
// DebitInterval: 0,
// NextAutoDebit: time.Time{},
// },
// }
// aSessions2 := make([]*sessions.ExternalSession, 0)
// if err := smgRplcRPC1.Call(utils.SessionSv1GetPassiveSessions, &utils.SessionFilter{}, &aSessions2); err != nil {
// t.Error(err)
// }
// if !reflect.DeepEqual(&aSessions2, &expected) {
// t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(&aSessions2), utils.ToJSON(&expected))
}
}
// }
// }
func testSessionSRplcStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSessionSRplcStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

376
general_tests/session_it_test.go
View File

@@ -20,206 +20,206 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"net/rpc"
"path"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// )
var (
sesCfgPath string
sesCfgDIR string
sesCfg *config.CGRConfig
sesRPC *rpc.Client
sesAccount = "refundAcc"
sesTenant = "cgrates.org"
// var (
// sesCfgPath string
// sesCfgDIR string
// sesCfg *config.CGRConfig
// sesRPC *rpc.Client
// sesAccount = "refundAcc"
// sesTenant = "cgrates.org"
sTestSesIt = []func(t *testing.T){
testSesItLoadConfig,
testSesItResetDataDB,
testSesItResetStorDb,
testSesItStartEngine,
testSesItRPCConn,
testSesItLoadFromFolder,
testSesItAddVoiceBalance,
testSesItInitSession,
testSesItTerminateSession,
testSesItStopCgrEngine,
}
)
// sTestSesIt = []func(t *testing.T){
// testSesItLoadConfig,
// testSesItResetDataDB,
// testSesItResetStorDb,
// testSesItStartEngine,
// testSesItRPCConn,
// testSesItLoadFromFolder,
// testSesItAddVoiceBalance,
// testSesItInitSession,
// testSesItTerminateSession,
// testSesItStopCgrEngine,
// }
// )
func TestSesIt(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
sesCfgDIR = "tutinternal"
case utils.MetaMySQL:
sesCfgDIR = "tutmysql_internal"
case utils.MetaMongo:
sesCfgDIR = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestSesIt {
t.Run(sesCfgDIR, stest)
}
}
// func TestSesIt(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// sesCfgDIR = "tutinternal"
// case utils.MetaMySQL:
// sesCfgDIR = "tutmysql_internal"
// case utils.MetaMongo:
// sesCfgDIR = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sTestSesIt {
// t.Run(sesCfgDIR, stest)
// }
// }
// test for 0 balance with session terminate with 1s usage
func testSesItLoadConfig(t *testing.T) {
sesCfgPath = path.Join(*dataDir, "conf", "samples", sesCfgDIR)
if sesCfg, err = config.NewCGRConfigFromPath(sesCfgPath); err != nil {
t.Error(err)
}
}
// // test for 0 balance with session terminate with 1s usage
// func testSesItLoadConfig(t *testing.T) {
// sesCfgPath = path.Join(*dataDir, "conf", "samples", sesCfgDIR)
// if sesCfg, err = config.NewCGRConfigFromPath(sesCfgPath); err != nil {
// t.Error(err)
// }
// }
func testSesItResetDataDB(t *testing.T) {
if err := engine.InitDataDB(sesCfg); err != nil {
t.Fatal(err)
}
}
// func testSesItResetDataDB(t *testing.T) {
// if err := engine.InitDataDB(sesCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSesItResetStorDb(t *testing.T) {
if err := engine.InitStorDB(sesCfg); err != nil {
t.Fatal(err)
}
}
// func testSesItResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(sesCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSesItStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(sesCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testSesItStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(sesCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testSesItRPCConn(t *testing.T) {
var err error
sesRPC, err = newRPCClient(sesCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testSesItRPCConn(t *testing.T) {
// var err error
// sesRPC, err = newRPCClient(sesCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testSesItLoadFromFolder(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")}
if err := sesRPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
}
time.Sleep(100 * time.Millisecond)
}
// func testSesItLoadFromFolder(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")}
// if err := sesRPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// }
// time.Sleep(100 * time.Millisecond)
// }
func testAccountBalance2(t *testing.T, sracc, srten, balType string, expected float64) {
var acnt engine.Account
attrs := &utils.AttrGetAccount{
Tenant: srten,
Account: sracc,
}
if err := sesRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error(err)
} else if rply := acnt.BalanceMap[balType].GetTotalValue(); rply != expected {
t.Errorf("Expecting: %v, received: %v",
expected, rply)
}
}
// func testAccountBalance2(t *testing.T, sracc, srten, balType string, expected float64) {
// var acnt engine.Account
// attrs := &utils.AttrGetAccount{
// Tenant: srten,
// Account: sracc,
// }
// if err := sesRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error(err)
// } else if rply := acnt.BalanceMap[balType].GetTotalValue(); rply != expected {
// t.Errorf("Expecting: %v, received: %v",
// expected, rply)
// }
// }
func testSesItAddVoiceBalance(t *testing.T) {
attrSetBalance := utils.AttrSetBalance{
Tenant: sesTenant,
Account: sesAccount,
BalanceType: utils.MetaMonetary,
Value: 0,
Balance: map[string]interface{}{
utils.ID: "TestDynamicDebitBalance",
utils.RatingSubject: "*zero1s",
},
}
var reply string
if err := sesRPC.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Received: %s", reply)
}
t.Run("TestAddVoiceBalance", func(t *testing.T) { testAccountBalance2(t, sesAccount, sesTenant, utils.MetaMonetary, 0) })
}
// func testSesItAddVoiceBalance(t *testing.T) {
// attrSetBalance := utils.AttrSetBalance{
// Tenant: sesTenant,
// Account: sesAccount,
// BalanceType: utils.MetaMonetary,
// Value: 0,
// Balance: map[string]interface{}{
// utils.ID: "TestDynamicDebitBalance",
// utils.RatingSubject: "*zero1s",
// },
// }
// var reply string
// if err := sesRPC.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Received: %s", reply)
// }
// t.Run("TestAddVoiceBalance", func(t *testing.T) { testAccountBalance2(t, sesAccount, sesTenant, utils.MetaMonetary, 0) })
// }
func testSesItInitSession(t *testing.T) {
args1 := &sessions.V1InitSessionArgs{
InitSession: true,
CGREvent: &utils.CGREvent{
Tenant: sesTenant,
ID: "TestSesItInitiateSession",
Event: map[string]interface{}{
utils.Tenant: sesTenant,
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestRefund",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: sesAccount,
utils.Subject: "TEST",
utils.Destination: "TEST",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 5 * time.Second,
},
},
}
var rply1 sessions.V1InitSessionReply
if err := sesRPC.Call(utils.SessionSv1InitiateSession,
args1, &rply1); err != nil {
t.Error(err)
return
} else if rply1.MaxUsage != nil && *rply1.MaxUsage != 0 {
t.Errorf("Unexpected MaxUsage: %v", rply1.MaxUsage)
}
t.Run("TestInitSession", func(t *testing.T) { testAccountBalance2(t, sesAccount, sesTenant, utils.MetaMonetary, 0) })
}
// func testSesItInitSession(t *testing.T) {
// args1 := &sessions.V1InitSessionArgs{
// InitSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: sesTenant,
// ID: "TestSesItInitiateSession",
// Event: map[string]interface{}{
// utils.Tenant: sesTenant,
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestRefund",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: sesAccount,
// utils.Subject: "TEST",
// utils.Destination: "TEST",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 5 * time.Second,
// },
// },
// }
// var rply1 sessions.V1InitSessionReply
// if err := sesRPC.Call(utils.SessionSv1InitiateSession,
// args1, &rply1); err != nil {
// t.Error(err)
// return
// } else if rply1.MaxUsage != nil && *rply1.MaxUsage != 0 {
// t.Errorf("Unexpected MaxUsage: %v", rply1.MaxUsage)
// }
// t.Run("TestInitSession", func(t *testing.T) { testAccountBalance2(t, sesAccount, sesTenant, utils.MetaMonetary, 0) })
// }
func testSesItTerminateSession(t *testing.T) {
args := &sessions.V1TerminateSessionArgs{
TerminateSession: true,
CGREvent: &utils.CGREvent{
Tenant: sesTenant,
ID: "TestSesItUpdateSession",
Event: map[string]interface{}{
utils.Tenant: sesTenant,
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestRefund",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: sesAccount,
utils.Subject: "TEST",
utils.Destination: "TEST",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: time.Second,
},
},
}
var rply string
if err := sesRPC.Call(utils.SessionSv1TerminateSession,
args, &rply); err != nil {
t.Error(err)
}
if rply != utils.OK {
t.Errorf("Unexpected reply: %s", rply)
}
aSessions := make([]*sessions.ExternalSession, 0)
if err := sesRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
t.Run("TestTerminateSession", func(t *testing.T) { testAccountBalance2(t, sesAccount, sesTenant, utils.MetaMonetary, 0) })
}
// func testSesItTerminateSession(t *testing.T) {
// args := &sessions.V1TerminateSessionArgs{
// TerminateSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: sesTenant,
// ID: "TestSesItUpdateSession",
// Event: map[string]interface{}{
// utils.Tenant: sesTenant,
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestRefund",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: sesAccount,
// utils.Subject: "TEST",
// utils.Destination: "TEST",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: time.Second,
// },
// },
// }
// var rply string
// if err := sesRPC.Call(utils.SessionSv1TerminateSession,
// args, &rply); err != nil {
// t.Error(err)
// }
// if rply != utils.OK {
// t.Errorf("Unexpected reply: %s", rply)
// }
// aSessions := make([]*sessions.ExternalSession, 0)
// if err := sesRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// t.Run("TestTerminateSession", func(t *testing.T) { testAccountBalance2(t, sesAccount, sesTenant, utils.MetaMonetary, 0) })
// }
func testSesItStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSesItStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

252
general_tests/session_nonereq_it_test.go
View File

@@ -21,143 +21,143 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// )
var (
sesNoneReqTypeCfgDir string
sesNoneReqTypeCfgPath string
sesNoneReqTypeCfg *config.CGRConfig
sesNoneReqTypeRPC *rpc.Client
// var (
// sesNoneReqTypeCfgDir string
// sesNoneReqTypeCfgPath string
// sesNoneReqTypeCfg *config.CGRConfig
// sesNoneReqTypeRPC *rpc.Client
sesNoneReqTypeTests = []func(t *testing.T){
testSesNoneReqTypeItLoadConfig,
testSesNoneReqTypeItResetDataDB,
testSesNoneReqTypeItResetStorDb,
testSesNoneReqTypeItStartEngine,
testSesNoneReqTypeItRPCConn,
// sesNoneReqTypeTests = []func(t *testing.T){
// testSesNoneReqTypeItLoadConfig,
// testSesNoneReqTypeItResetDataDB,
// testSesNoneReqTypeItResetStorDb,
// testSesNoneReqTypeItStartEngine,
// testSesNoneReqTypeItRPCConn,
testSesNoneReqTypeItAddChargerS,
testSesNoneReqTypeItInit,
// testSesNoneReqTypeItAddChargerS,
// testSesNoneReqTypeItInit,
testSesNoneReqTypeItStopEngine,
}
)
// testSesNoneReqTypeItStopEngine,
// }
// )
func TestSesNoneReqTypeItSessions(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
sesNoneReqTypeCfgDir = "tutinternal"
case utils.MetaMySQL:
sesNoneReqTypeCfgDir = "tutmysql"
case utils.MetaMongo:
sesNoneReqTypeCfgDir = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sesNoneReqTypeTests {
t.Run(sesNoneReqTypeCfgDir, stest)
}
}
// func TestSesNoneReqTypeItSessions(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// sesNoneReqTypeCfgDir = "tutinternal"
// case utils.MetaMySQL:
// sesNoneReqTypeCfgDir = "tutmysql"
// case utils.MetaMongo:
// sesNoneReqTypeCfgDir = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sesNoneReqTypeTests {
// t.Run(sesNoneReqTypeCfgDir, stest)
// }
// }
func testSesNoneReqTypeItLoadConfig(t *testing.T) {
sesNoneReqTypeCfgPath = path.Join(*dataDir, "conf", "samples", sesNoneReqTypeCfgDir)
if sesNoneReqTypeCfg, err = config.NewCGRConfigFromPath(sesNoneReqTypeCfgPath); err != nil {
t.Error(err)
}
}
// func testSesNoneReqTypeItLoadConfig(t *testing.T) {
// sesNoneReqTypeCfgPath = path.Join(*dataDir, "conf", "samples", sesNoneReqTypeCfgDir)
// if sesNoneReqTypeCfg, err = config.NewCGRConfigFromPath(sesNoneReqTypeCfgPath); err != nil {
// t.Error(err)
// }
// }
func testSesNoneReqTypeItResetDataDB(t *testing.T) {
if err := engine.InitDataDb(sesNoneReqTypeCfg); err != nil {
t.Fatal(err)
}
}
// func testSesNoneReqTypeItResetDataDB(t *testing.T) {
// if err := engine.InitDataDb(sesNoneReqTypeCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSesNoneReqTypeItResetStorDb(t *testing.T) {
if err := engine.InitStorDb(sesNoneReqTypeCfg); err != nil {
t.Fatal(err)
}
}
// func testSesNoneReqTypeItResetStorDb(t *testing.T) {
// if err := engine.InitStorDb(sesNoneReqTypeCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSesNoneReqTypeItStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(sesNoneReqTypeCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testSesNoneReqTypeItStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(sesNoneReqTypeCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testSesNoneReqTypeItRPCConn(t *testing.T) {
var err error
sesNoneReqTypeRPC, err = newRPCClient(sesNoneReqTypeCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testSesNoneReqTypeItRPCConn(t *testing.T) {
// var err error
// sesNoneReqTypeRPC, err = newRPCClient(sesNoneReqTypeCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testSesNoneReqTypeItAddChargerS(t *testing.T) {
//add a default charger
chargerProfile := &v1.ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "Default",
RunID: utils.MetaDefault,
AttributeIDs: []string{"*none"},
Weight: 20,
},
}
var result string
if err := sesNoneReqTypeRPC.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
}
// func testSesNoneReqTypeItAddChargerS(t *testing.T) {
// //add a default charger
// chargerProfile := &v1.ChargerWithAPIOpts{
// ChargerProfile: &engine.ChargerProfile{
// Tenant: "cgrates.org",
// ID: "Default",
// RunID: utils.MetaDefault,
// AttributeIDs: []string{"*none"},
// Weight: 20,
// },
// }
// var result string
// if err := sesNoneReqTypeRPC.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
// }
func testSesNoneReqTypeItInit(t *testing.T) {
args1 := &sessions.V1InitSessionArgs{
InitSession: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
utils.CGRID: "cgrID",
utils.Category: utils.Call,
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestReqNone",
utils.RequestType: utils.MetaNone,
utils.AccountField: "1001",
utils.Subject: "1001",
utils.Destination: "1002",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 10 * time.Second,
},
APIOpts: map[string]interface{}{
utils.OptsSesDebitInterval: "0s",
},
},
}
var rply1 sessions.V1InitSessionReply
if err := sesNoneReqTypeRPC.Call(utils.SessionSv1InitiateSession,
args1, &rply1); err != nil {
t.Error(err)
return
} else if rply1.MaxUsage != nil && *rply1.MaxUsage != 10*time.Second {
t.Errorf("Unexpected MaxUsage: %v", rply1.MaxUsage)
}
}
// func testSesNoneReqTypeItInit(t *testing.T) {
// args1 := &sessions.V1InitSessionArgs{
// InitSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// utils.CGRID: "cgrID",
// utils.Category: utils.Call,
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestReqNone",
// utils.RequestType: utils.MetaNone,
// utils.AccountField: "1001",
// utils.Subject: "1001",
// utils.Destination: "1002",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 10 * time.Second,
// },
// APIOpts: map[string]interface{}{
// utils.OptsSesDebitInterval: "0s",
// },
// },
// }
// var rply1 sessions.V1InitSessionReply
// if err := sesNoneReqTypeRPC.Call(utils.SessionSv1InitiateSession,
// args1, &rply1); err != nil {
// t.Error(err)
// return
// } else if rply1.MaxUsage != nil && *rply1.MaxUsage != 10*time.Second {
// t.Errorf("Unexpected MaxUsage: %v", rply1.MaxUsage)
// }
// }
func testSesNoneReqTypeItStopEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSesNoneReqTypeItStopEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

728
general_tests/session_replications_automaticdebit_it_test.go
View File

@@ -20,394 +20,394 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"fmt"
"net/rpc"
"os/exec"
"path"
"testing"
"time"
// import (
// "fmt"
// "net/rpc"
// "os/exec"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// )
var (
smgRplcMasterCfgPath, smgRplcSlaveCfgPath string
smgRplcMasterCfgDIR, smgRplcSlaveCfgDIR string
smgRplcMasterCfg, smgRplcSlaveCfg *config.CGRConfig
smgRplcMstrRPC, smgRplcSlvRPC *rpc.Client
masterEngine *exec.Cmd
sTestsSession = []func(t *testing.T){
testSessionSRplInitCfg,
testSessionSRplResetDB,
testSessionSRplStartEngine,
testSessionSRplApierRpcConn,
testSessionSRplTPFromFolder,
testSessionSRplAddVoiceBalance,
testSessionSRplInitiate,
testSessionSRplActivateSlave,
testSessionSRplCheckAccount,
testSessionSRplTerminate,
testSessionSRplStopCgrEngine,
}
)
// var (
// smgRplcMasterCfgPath, smgRplcSlaveCfgPath string
// smgRplcMasterCfgDIR, smgRplcSlaveCfgDIR string
// smgRplcMasterCfg, smgRplcSlaveCfg *config.CGRConfig
// smgRplcMstrRPC, smgRplcSlvRPC *rpc.Client
// masterEngine *exec.Cmd
// sTestsSession = []func(t *testing.T){
// testSessionSRplInitCfg,
// testSessionSRplResetDB,
// testSessionSRplStartEngine,
// testSessionSRplApierRpcConn,
// testSessionSRplTPFromFolder,
// testSessionSRplAddVoiceBalance,
// testSessionSRplInitiate,
// testSessionSRplActivateSlave,
// testSessionSRplCheckAccount,
// testSessionSRplTerminate,
// testSessionSRplStopCgrEngine,
// }
// )
func TestSessionSRpl(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
t.SkipNow()
case utils.MetaMySQL:
smgRplcMasterCfgDIR = "smgreplcmaster_mysql"
smgRplcSlaveCfgDIR = "smgreplcslave_mysql"
case utils.MetaMongo:
smgRplcMasterCfgDIR = "smgreplcmaster_mongo"
smgRplcSlaveCfgDIR = "smgreplcslave_mongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
// func TestSessionSRpl(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// t.SkipNow()
// case utils.MetaMySQL:
// smgRplcMasterCfgDIR = "smgreplcmaster_mysql"
// smgRplcSlaveCfgDIR = "smgreplcslave_mysql"
// case utils.MetaMongo:
// smgRplcMasterCfgDIR = "smgreplcmaster_mongo"
// smgRplcSlaveCfgDIR = "smgreplcslave_mongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
for _, stest := range sTestsSession {
t.Run(*dbType, stest)
}
}
// for _, stest := range sTestsSession {
// t.Run(*dbType, stest)
// }
// }
//topup
func testSessionSRplAddVoiceBalance(t *testing.T) {
attrSetBalance := utils.AttrSetBalance{
Tenant: "cgrates.org",
Account: "1005",
BalanceType: utils.MetaVoice,
Value: 5 * float64(time.Second), //value -> 20ms for future
Balance: map[string]interface{}{
utils.ID: "TestDynamicDebitBalance",
utils.RatingSubject: "*zero5ms",
},
}
var reply string
if err := smgRplcMstrRPC.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Received: %s", reply)
}
var acnt *engine.Account
attrs := &utils.AttrGetAccount{
Tenant: "cgrates.org",
Account: "1005",
}
//get balance
if err := smgRplcMstrRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error(err)
} else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply != float64(5*time.Second) {
t.Errorf("Expecting: %v, received: %v",
float64(5*time.Second), rply)
}
}
// //topup
// func testSessionSRplAddVoiceBalance(t *testing.T) {
// attrSetBalance := utils.AttrSetBalance{
// Tenant: "cgrates.org",
// Account: "1005",
// BalanceType: utils.MetaVoice,
// Value: 5 * float64(time.Second), //value -> 20ms for future
// Balance: map[string]interface{}{
// utils.ID: "TestDynamicDebitBalance",
// utils.RatingSubject: "*zero5ms",
// },
// }
// var reply string
// if err := smgRplcMstrRPC.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Received: %s", reply)
// }
// var acnt *engine.Account
// attrs := &utils.AttrGetAccount{
// Tenant: "cgrates.org",
// Account: "1005",
// }
// //get balance
// if err := smgRplcMstrRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error(err)
// } else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply != float64(5*time.Second) {
// t.Errorf("Expecting: %v, received: %v",
// float64(5*time.Second), rply)
// }
// }
//Init Config
func testSessionSRplInitCfg(t *testing.T) {
smgRplcMasterCfgPath = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcMasterCfgDIR)
if smgRplcMasterCfg, err = config.NewCGRConfigFromPath(smgRplcMasterCfgPath); err != nil {
t.Fatal(err)
}
smgRplcSlaveCfgPath = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcSlaveCfgDIR)
if smgRplcSlaveCfg, err = config.NewCGRConfigFromPath(smgRplcSlaveCfgPath); err != nil {
t.Fatal(err)
}
}
// //Init Config
// func testSessionSRplInitCfg(t *testing.T) {
// smgRplcMasterCfgPath = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcMasterCfgDIR)
// if smgRplcMasterCfg, err = config.NewCGRConfigFromPath(smgRplcMasterCfgPath); err != nil {
// t.Fatal(err)
// }
// smgRplcSlaveCfgPath = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcSlaveCfgDIR)
// if smgRplcSlaveCfg, err = config.NewCGRConfigFromPath(smgRplcSlaveCfgPath); err != nil {
// t.Fatal(err)
// }
// }
// Remove data in both rating and accounting db
func testSessionSRplResetDB(t *testing.T) {
if err := engine.InitDataDB(smgRplcMasterCfg); err != nil {
t.Fatal(err)
}
if err := engine.InitStorDB(smgRplcMasterCfg); err != nil {
t.Fatal(err)
}
}
// // Remove data in both rating and accounting db
// func testSessionSRplResetDB(t *testing.T) {
// if err := engine.InitDataDB(smgRplcMasterCfg); err != nil {
// t.Fatal(err)
// }
// if err := engine.InitStorDB(smgRplcMasterCfg); err != nil {
// t.Fatal(err)
// }
// }
// Start CGR Engine
func testSessionSRplStartEngine(t *testing.T) {
if _, err = engine.StopStartEngine(smgRplcSlaveCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
if masterEngine, err = engine.StartEngine(smgRplcMasterCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
// // Start CGR Engine
// func testSessionSRplStartEngine(t *testing.T) {
// if _, err = engine.StopStartEngine(smgRplcSlaveCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// if masterEngine, err = engine.StartEngine(smgRplcMasterCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
}
// }
// Connect rpc client to rater
func testSessionSRplApierRpcConn(t *testing.T) {
if smgRplcMstrRPC, err = newRPCClient(smgRplcMasterCfg.ListenCfg()); err != nil {
t.Fatal(err)
}
if smgRplcSlvRPC, err = newRPCClient(smgRplcSlaveCfg.ListenCfg()); err != nil {
t.Fatal(err)
}
}
// // Connect rpc client to rater
// func testSessionSRplApierRpcConn(t *testing.T) {
// if smgRplcMstrRPC, err = newRPCClient(smgRplcMasterCfg.ListenCfg()); err != nil {
// t.Fatal(err)
// }
// if smgRplcSlvRPC, err = newRPCClient(smgRplcSlaveCfg.ListenCfg()); err != nil {
// t.Fatal(err)
// }
// }
// Load the tariff plan, creating accounts and their balances
func testSessionSRplTPFromFolder(t *testing.T) {
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")}
var loadInst utils.LoadInstance
if err := smgRplcMstrRPC.Call(utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil {
t.Error(err)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups
}
// // Load the tariff plan, creating accounts and their balances
// func testSessionSRplTPFromFolder(t *testing.T) {
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")}
// var loadInst utils.LoadInstance
// if err := smgRplcMstrRPC.Call(utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil {
// t.Error(err)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups
// }
func testSessionSRplInitiate(t *testing.T) {
var aSessions []*sessions.ExternalSession
//make sure we don't have active sessions on master and passive on slave
if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions,
new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions,
new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
// func testSessionSRplInitiate(t *testing.T) {
// var aSessions []*sessions.ExternalSession
// //make sure we don't have active sessions on master and passive on slave
// if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions,
// new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions,
// new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
argsInit := &sessions.V1InitSessionArgs{
InitSession: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSessionSRplInitiate",
Event: map[string]interface{}{
utils.EventName: "TEST_EVENT",
utils.Tenant: "cgrates.org",
utils.OriginID: "123451",
utils.ToR: utils.MetaVoice,
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1005",
utils.Subject: "1005",
utils.Destination: "1004",
utils.Category: "call",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 0,
},
},
}
// argsInit := &sessions.V1InitSessionArgs{
// InitSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSessionSRplInitiate",
// Event: map[string]interface{}{
// utils.EventName: "TEST_EVENT",
// utils.Tenant: "cgrates.org",
// utils.OriginID: "123451",
// utils.ToR: utils.MetaVoice,
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: "1005",
// utils.Subject: "1005",
// utils.Destination: "1004",
// utils.Category: "call",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 0,
// },
// },
// }
var initRpl sessions.V1InitSessionReply
if err := smgRplcMstrRPC.Call(utils.SessionSv1InitiateSession,
argsInit, &initRpl); err != nil {
t.Error(err)
}
//compare the value
eMaxUsage := 3 * time.Hour // MaxCallDuration from config
if initRpl.MaxUsage == nil || *initRpl.MaxUsage != eMaxUsage {
t.Errorf("Expecting : %+v, received: %+v", eMaxUsage, initRpl.MaxUsage)
}
// var initRpl sessions.V1InitSessionReply
// if err := smgRplcMstrRPC.Call(utils.SessionSv1InitiateSession,
// argsInit, &initRpl); err != nil {
// t.Error(err)
// }
// //compare the value
// eMaxUsage := 3 * time.Hour // MaxCallDuration from config
// if initRpl.MaxUsage == nil || *initRpl.MaxUsage != eMaxUsage {
// t.Errorf("Expecting : %+v, received: %+v", eMaxUsage, initRpl.MaxUsage)
// }
//check active session
time.Sleep(10 * time.Millisecond)
if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions,
utils.SessionFilter{
Filters: []string{
fmt.Sprintf("*string:~*req.%s:%s", utils.OriginID, "123451"),
},
}, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 {
t.Errorf("Unexpected number of sessions received: %+v", utils.ToIJSON(aSessions))
// a tolerance of +/- 5ms is acceptable
} else if aSessions[0].Usage < 5*time.Millisecond || aSessions[0].Usage > 15*time.Millisecond {
t.Errorf("Expecting : ~%+v, received: %+v", 10*time.Millisecond, aSessions[0].Usage) //here
}
//check passive session
var autoDebit1, autoDebit2 time.Time
// //check active session
// time.Sleep(10 * time.Millisecond)
// if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions,
// utils.SessionFilter{
// Filters: []string{
// fmt.Sprintf("*string:~*req.%s:%s", utils.OriginID, "123451"),
// },
// }, &aSessions); err != nil {
// t.Error(err)
// } else if len(aSessions) != 1 {
// t.Errorf("Unexpected number of sessions received: %+v", utils.ToIJSON(aSessions))
// // a tolerance of +/- 5ms is acceptable
// } else if aSessions[0].Usage < 5*time.Millisecond || aSessions[0].Usage > 15*time.Millisecond {
// t.Errorf("Expecting : ~%+v, received: %+v", 10*time.Millisecond, aSessions[0].Usage) //here
// }
// //check passive session
// var autoDebit1, autoDebit2 time.Time
var pSessions []*sessions.ExternalSession
if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions,
utils.SessionFilter{
Filters: []string{
fmt.Sprintf("*string:~*req.%s:%s", utils.OriginID, "123451"),
},
}, &pSessions); err != nil {
t.Error(err)
} else if len(pSessions) != 1 {
t.Errorf("PassiveSessions: %+v", pSessions)
} else if pSessions[0].Usage < 5*time.Millisecond || pSessions[0].Usage > 15*time.Millisecond {
t.Errorf("Expecting : %+v, received: %+v", 10*time.Millisecond, pSessions[0].Usage)
} else if autoDebit1 = pSessions[0].NextAutoDebit; autoDebit1.IsZero() {
t.Errorf("unexpected NextAutoDebit: %s", utils.ToIJSON(aSessions[0]))
}
// var pSessions []*sessions.ExternalSession
// if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions,
// utils.SessionFilter{
// Filters: []string{
// fmt.Sprintf("*string:~*req.%s:%s", utils.OriginID, "123451"),
// },
// }, &pSessions); err != nil {
// t.Error(err)
// } else if len(pSessions) != 1 {
// t.Errorf("PassiveSessions: %+v", pSessions)
// } else if pSessions[0].Usage < 5*time.Millisecond || pSessions[0].Usage > 15*time.Millisecond {
// t.Errorf("Expecting : %+v, received: %+v", 10*time.Millisecond, pSessions[0].Usage)
// } else if autoDebit1 = pSessions[0].NextAutoDebit; autoDebit1.IsZero() {
// t.Errorf("unexpected NextAutoDebit: %s", utils.ToIJSON(aSessions[0]))
// }
//check active session (II)
time.Sleep(12 * time.Millisecond)
if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions,
utils.SessionFilter{
Filters: []string{
fmt.Sprintf("*string:~*req.%s:%s", utils.OriginID, "123451"),
},
}, &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 {
t.Errorf("Unexpected number of sessions received: %+v", utils.ToIJSON(aSessions))
// a tolerance of +/- 5ms is acceptable
} else if aSessions[0].Usage < 15*time.Millisecond || aSessions[0].Usage > 25*time.Millisecond {
t.Errorf("Expecting : ~%+v, received: %+v", 20*time.Millisecond, aSessions[0].Usage) //here
}
// //check active session (II)
// time.Sleep(12 * time.Millisecond)
// if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions,
// utils.SessionFilter{
// Filters: []string{
// fmt.Sprintf("*string:~*req.%s:%s", utils.OriginID, "123451"),
// },
// }, &aSessions); err != nil {
// t.Error(err)
// } else if len(aSessions) != 1 {
// t.Errorf("Unexpected number of sessions received: %+v", utils.ToIJSON(aSessions))
// // a tolerance of +/- 5ms is acceptable
// } else if aSessions[0].Usage < 15*time.Millisecond || aSessions[0].Usage > 25*time.Millisecond {
// t.Errorf("Expecting : ~%+v, received: %+v", 20*time.Millisecond, aSessions[0].Usage) //here
// }
//check passive session (II)
if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions,
utils.SessionFilter{
Filters: []string{
fmt.Sprintf("*string:~*req.%s:%s", utils.OriginID, "123451"),
},
}, &pSessions); err != nil {
t.Error(err)
} else if len(pSessions) != 1 {
t.Errorf("PassiveSessions: %+v", pSessions)
} else if pSessions[0].Usage <= 10*time.Millisecond || pSessions[0].Usage >= 30*time.Millisecond {
t.Errorf("Expecting : %+v, received: %+v", 20*time.Millisecond, pSessions[0].Usage)
} else if autoDebit2 = pSessions[0].NextAutoDebit; autoDebit2.IsZero() {
t.Errorf("unexpected NextAutoDebit: %s", utils.ToIJSON(aSessions[0]))
} else if autoDebit1 == autoDebit2 {
t.Error("Expecting NextAutoDebit to be different from the previous one")
}
// //check passive session (II)
// if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions,
// utils.SessionFilter{
// Filters: []string{
// fmt.Sprintf("*string:~*req.%s:%s", utils.OriginID, "123451"),
// },
// }, &pSessions); err != nil {
// t.Error(err)
// } else if len(pSessions) != 1 {
// t.Errorf("PassiveSessions: %+v", pSessions)
// } else if pSessions[0].Usage <= 10*time.Millisecond || pSessions[0].Usage >= 30*time.Millisecond {
// t.Errorf("Expecting : %+v, received: %+v", 20*time.Millisecond, pSessions[0].Usage)
// } else if autoDebit2 = pSessions[0].NextAutoDebit; autoDebit2.IsZero() {
// t.Errorf("unexpected NextAutoDebit: %s", utils.ToIJSON(aSessions[0]))
// } else if autoDebit1 == autoDebit2 {
// t.Error("Expecting NextAutoDebit to be different from the previous one")
// }
//get balance
var acnt *engine.Account
attrs := &utils.AttrGetAccount{
Tenant: "cgrates.org",
Account: "1005",
}
if err := smgRplcMstrRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error(err)
// a tolerance of +/- 5ms is acceptable
} else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply < float64(5*time.Second-25*time.Millisecond) || rply > float64(5*time.Second-15*time.Millisecond) {
t.Errorf("Expecting: ~%v, received: %v", float64(5*time.Second-20*time.Millisecond), rply)
}
}
// //get balance
// var acnt *engine.Account
// attrs := &utils.AttrGetAccount{
// Tenant: "cgrates.org",
// Account: "1005",
// }
// if err := smgRplcMstrRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error(err)
// // a tolerance of +/- 5ms is acceptable
// } else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply < float64(5*time.Second-25*time.Millisecond) || rply > float64(5*time.Second-15*time.Millisecond) {
// t.Errorf("Expecting: ~%v, received: %v", float64(5*time.Second-20*time.Millisecond), rply)
// }
// }
func testSessionSRplActivateSlave(t *testing.T) {
//stop the master engine
if err := masterEngine.Process.Kill(); err != nil {
t.Error(err)
}
// activate sessions on slave
var rplActivate string
if err := smgRplcSlvRPC.Call(utils.SessionSv1ActivateSessions, &utils.SessionIDsWithAPIOpts{}, &rplActivate); err != nil {
t.Error(err)
}
time.Sleep(7 * time.Millisecond)
//check if the active session is on slave now
var aSessions []*sessions.ExternalSession
var autoDebit1, autoDebit2 time.Time
if err := smgRplcSlvRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil {
t.Error(err)
} else if len(aSessions) != 1 {
t.Errorf("Unexpected number of sessions received: %+v", utils.ToIJSON(aSessions))
// a tolerance of +/- 5ms is acceptable
} else if aSessions[0].Usage < 20*time.Millisecond || aSessions[0].Usage > 30*time.Millisecond {
t.Errorf("Expecting : ~%+v, received: %+v", 25*time.Millisecond, aSessions[0].Usage) //here
} else if autoDebit1 = aSessions[0].NextAutoDebit; autoDebit1.IsZero() {
t.Errorf("unexpected NextAutoDebit: %s", utils.ToIJSON(aSessions[0]))
}
var aSessions2 []*sessions.ExternalSession
// start the initial engine so the replication can happen normally
if masterEngine, err = engine.StartEngine(smgRplcMasterCfgPath, 10); err != nil {
t.Fatal(err)
}
time.Sleep(20 * time.Millisecond)
if err := smgRplcSlvRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions2); err != nil {
t.Error(err)
} else if len(aSessions2) != 1 {
t.Errorf("Unexpected number of sessions received: %+v", utils.ToIJSON(aSessions2))
// a tolerance of +/- 5ms is acceptable
} else if aSessions2[0].Usage < 20*time.Millisecond || aSessions2[0].Usage > 40*time.Millisecond {
t.Errorf("Expecting : ~%+v, received: %+v", 40*time.Millisecond, aSessions2[0].Usage) //here
} else if autoDebit2 = aSessions2[0].NextAutoDebit; autoDebit2.IsZero() {
t.Errorf("unexpected NextAutoDebit: %s", utils.ToIJSON(aSessions2[0]))
} else if autoDebit1 == autoDebit2 {
t.Error("Expecting NextAutoDebit to be different from the previous one")
t.Errorf("%+v and %+v", autoDebit1, autoDebit2)
}
}
// func testSessionSRplActivateSlave(t *testing.T) {
// //stop the master engine
// if err := masterEngine.Process.Kill(); err != nil {
// t.Error(err)
// }
// // activate sessions on slave
// var rplActivate string
// if err := smgRplcSlvRPC.Call(utils.SessionSv1ActivateSessions, &utils.SessionIDsWithAPIOpts{}, &rplActivate); err != nil {
// t.Error(err)
// }
// time.Sleep(7 * time.Millisecond)
// //check if the active session is on slave now
// var aSessions []*sessions.ExternalSession
// var autoDebit1, autoDebit2 time.Time
// if err := smgRplcSlvRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil {
// t.Error(err)
// } else if len(aSessions) != 1 {
// t.Errorf("Unexpected number of sessions received: %+v", utils.ToIJSON(aSessions))
// // a tolerance of +/- 5ms is acceptable
// } else if aSessions[0].Usage < 20*time.Millisecond || aSessions[0].Usage > 30*time.Millisecond {
// t.Errorf("Expecting : ~%+v, received: %+v", 25*time.Millisecond, aSessions[0].Usage) //here
// } else if autoDebit1 = aSessions[0].NextAutoDebit; autoDebit1.IsZero() {
// t.Errorf("unexpected NextAutoDebit: %s", utils.ToIJSON(aSessions[0]))
// }
// var aSessions2 []*sessions.ExternalSession
// // start the initial engine so the replication can happen normally
// if masterEngine, err = engine.StartEngine(smgRplcMasterCfgPath, 10); err != nil {
// t.Fatal(err)
// }
// time.Sleep(20 * time.Millisecond)
// if err := smgRplcSlvRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions2); err != nil {
// t.Error(err)
// } else if len(aSessions2) != 1 {
// t.Errorf("Unexpected number of sessions received: %+v", utils.ToIJSON(aSessions2))
// // a tolerance of +/- 5ms is acceptable
// } else if aSessions2[0].Usage < 20*time.Millisecond || aSessions2[0].Usage > 40*time.Millisecond {
// t.Errorf("Expecting : ~%+v, received: %+v", 40*time.Millisecond, aSessions2[0].Usage) //here
// } else if autoDebit2 = aSessions2[0].NextAutoDebit; autoDebit2.IsZero() {
// t.Errorf("unexpected NextAutoDebit: %s", utils.ToIJSON(aSessions2[0]))
// } else if autoDebit1 == autoDebit2 {
// t.Error("Expecting NextAutoDebit to be different from the previous one")
// t.Errorf("%+v and %+v", autoDebit1, autoDebit2)
// }
// }
func testSessionSRplCheckAccount(t *testing.T) {
//check de account and make sure the session debit works correctly
var acnt *engine.Account
attrs := &utils.AttrGetAccount{
Tenant: "cgrates.org",
Account: "1005",
}
// func testSessionSRplCheckAccount(t *testing.T) {
// //check de account and make sure the session debit works correctly
// var acnt *engine.Account
// attrs := &utils.AttrGetAccount{
// Tenant: "cgrates.org",
// Account: "1005",
// }
expectedBal := 5*time.Second - 40*time.Millisecond
if err := smgRplcSlvRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error(err)
// a tolerance of +/- 10ms is acceptable
} else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply < float64(expectedBal-10*time.Millisecond) ||
rply > float64(expectedBal+10*time.Millisecond) {
t.Errorf("Expecting: ~%v, received: %v", expectedBal, time.Duration(rply))
}
}
// expectedBal := 5*time.Second - 40*time.Millisecond
// if err := smgRplcSlvRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error(err)
// // a tolerance of +/- 10ms is acceptable
// } else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply < float64(expectedBal-10*time.Millisecond) ||
// rply > float64(expectedBal+10*time.Millisecond) {
// t.Errorf("Expecting: ~%v, received: %v", expectedBal, time.Duration(rply))
// }
// }
func testSessionSRplTerminate(t *testing.T) {
args := &sessions.V1TerminateSessionArgs{
TerminateSession: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSessionSRplTerminate",
Event: map[string]interface{}{
utils.EventName: "TEST_EVENT",
utils.Tenant: "cgrates.org",
utils.OriginID: "123451",
utils.ToR: utils.MetaVoice,
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1005",
utils.Subject: "1005",
utils.Destination: "1004",
utils.Category: "call",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 2 * time.Second,
},
},
}
var reply string
if err := smgRplcSlvRPC.Call(utils.SessionSv1TerminateSession, args, &reply); err != nil {
t.Error(err)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Wait for the sessions to be populated
var aSessions []*sessions.ExternalSession
// func testSessionSRplTerminate(t *testing.T) {
// args := &sessions.V1TerminateSessionArgs{
// TerminateSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSessionSRplTerminate",
// Event: map[string]interface{}{
// utils.EventName: "TEST_EVENT",
// utils.Tenant: "cgrates.org",
// utils.OriginID: "123451",
// utils.ToR: utils.MetaVoice,
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: "1005",
// utils.Subject: "1005",
// utils.Destination: "1004",
// utils.Category: "call",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 2 * time.Second,
// },
// },
// }
// var reply string
// if err := smgRplcSlvRPC.Call(utils.SessionSv1TerminateSession, args, &reply); err != nil {
// t.Error(err)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Wait for the sessions to be populated
// var aSessions []*sessions.ExternalSession
//check if the session was terminated on slave
if err := smgRplcSlvRPC.Call(utils.SessionSv1GetActiveSessions,
new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("Error: %v with len(aSessions)=%v , session : %+v", err, len(aSessions), utils.ToIJSON(aSessions))
}
// check to don't have passive session on slave
var pSessions []*sessions.ExternalSession
if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions,
new(utils.SessionFilter), &pSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("Error: %v with len(pSessions)=%v , session : %+v", err, len(pSessions), utils.ToIJSON(pSessions))
}
// //check if the session was terminated on slave
// if err := smgRplcSlvRPC.Call(utils.SessionSv1GetActiveSessions,
// new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Errorf("Error: %v with len(aSessions)=%v , session : %+v", err, len(aSessions), utils.ToIJSON(aSessions))
// }
// // check to don't have passive session on slave
// var pSessions []*sessions.ExternalSession
// if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions,
// new(utils.SessionFilter), &pSessions); err == nil || err.Error() != utils.ErrNotFound.Error() {
// t.Errorf("Error: %v with len(pSessions)=%v , session : %+v", err, len(pSessions), utils.ToIJSON(pSessions))
// }
var acnt *engine.Account
attrs := &utils.AttrGetAccount{
Tenant: "cgrates.org",
Account: "1005",
}
// var acnt *engine.Account
// attrs := &utils.AttrGetAccount{
// Tenant: "cgrates.org",
// Account: "1005",
// }
if err := smgRplcSlvRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error(err)
// a tolerance of +/- 5ms is acceptable
} else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply != float64(3*time.Second) {
t.Errorf("Expecting: ~%v, received: %v", 3*time.Second, rply)
}
}
// if err := smgRplcSlvRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error(err)
// // a tolerance of +/- 5ms is acceptable
// } else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply != float64(3*time.Second) {
// t.Errorf("Expecting: ~%v, received: %v", 3*time.Second, rply)
// }
// }
func testSessionSRplStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSessionSRplStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

1766
general_tests/sessionpause_it_test.go
View File

File diff suppressed because it is too large Load Diff

564
general_tests/sessionrefund_it_test.go
View File

@@ -20,306 +20,306 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"net/rpc"
"path"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// )
var (
srCfgPath string
srCfgDIR string
srCfg *config.CGRConfig
srrpc *rpc.Client
sraccount = "refundAcc"
srtenant = "cgrates.org"
// var (
// srCfgPath string
// srCfgDIR string
// srCfg *config.CGRConfig
// srrpc *rpc.Client
// sraccount = "refundAcc"
// srtenant = "cgrates.org"
sTestSrIt = []func(t *testing.T){
testSrItLoadConfig,
testSrItResetDataDB,
testSrItResetStorDb,
testSrItStartEngine,
testSrItRPCConn,
testSrItLoadFromFolder,
testSrItAddVoiceBalance,
testSrItInitSession,
testSrItTerminateSession,
testSrItAddMonetaryBalance,
testSrItInitSession2,
testSrItTerminateSession2,
testSrItStopCgrEngine,
}
)
// sTestSrIt = []func(t *testing.T){
// testSrItLoadConfig,
// testSrItResetDataDB,
// testSrItResetStorDb,
// testSrItStartEngine,
// testSrItRPCConn,
// testSrItLoadFromFolder,
// testSrItAddVoiceBalance,
// testSrItInitSession,
// testSrItTerminateSession,
// testSrItAddMonetaryBalance,
// testSrItInitSession2,
// testSrItTerminateSession2,
// testSrItStopCgrEngine,
// }
// )
func TestSrIt(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
srCfgDIR = "tutinternal"
case utils.MetaMySQL:
srCfgDIR = "tutmysql_internal"
case utils.MetaMongo:
srCfgDIR = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestSrIt {
t.Run(srCfgDIR, stest)
}
}
// func TestSrIt(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// srCfgDIR = "tutinternal"
// case utils.MetaMySQL:
// srCfgDIR = "tutmysql_internal"
// case utils.MetaMongo:
// srCfgDIR = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sTestSrIt {
// t.Run(srCfgDIR, stest)
// }
// }
func testSrItLoadConfig(t *testing.T) {
srCfgPath = path.Join(*dataDir, "conf", "samples", srCfgDIR)
if srCfg, err = config.NewCGRConfigFromPath(srCfgPath); err != nil {
t.Error(err)
}
}
// func testSrItLoadConfig(t *testing.T) {
// srCfgPath = path.Join(*dataDir, "conf", "samples", srCfgDIR)
// if srCfg, err = config.NewCGRConfigFromPath(srCfgPath); err != nil {
// t.Error(err)
// }
// }
func testSrItResetDataDB(t *testing.T) {
if err := engine.InitDataDB(srCfg); err != nil {
t.Fatal(err)
}
}
// func testSrItResetDataDB(t *testing.T) {
// if err := engine.InitDataDB(srCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSrItResetStorDb(t *testing.T) {
if err := engine.InitStorDB(srCfg); err != nil {
t.Fatal(err)
}
}
// func testSrItResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(srCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSrItStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(srCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testSrItStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(srCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testSrItRPCConn(t *testing.T) {
var err error
srrpc, err = newRPCClient(srCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testSrItRPCConn(t *testing.T) {
// var err error
// srrpc, err = newRPCClient(srCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testSrItLoadFromFolder(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")}
if err := srrpc.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
}
time.Sleep(100 * time.Millisecond)
}
// func testSrItLoadFromFolder(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")}
// if err := srrpc.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// }
// time.Sleep(100 * time.Millisecond)
// }
func testAccountBalance(t *testing.T, sracc, srten, balType string, expected float64) {
var acnt *engine.Account
attrs := &utils.AttrGetAccount{
Tenant: srten,
Account: sracc,
}
if err := srrpc.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error(err)
} else if rply := acnt.BalanceMap[balType].GetTotalValue(); rply != expected {
t.Errorf("Expecting: %v, received: %v",
expected, rply)
}
}
// func testAccountBalance(t *testing.T, sracc, srten, balType string, expected float64) {
// var acnt *engine.Account
// attrs := &utils.AttrGetAccount{
// Tenant: srten,
// Account: sracc,
// }
// if err := srrpc.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error(err)
// } else if rply := acnt.BalanceMap[balType].GetTotalValue(); rply != expected {
// t.Errorf("Expecting: %v, received: %v",
// expected, rply)
// }
// }
func testSrItAddVoiceBalance(t *testing.T) {
attrSetBalance := utils.AttrSetBalance{
Tenant: srtenant,
Account: sraccount,
BalanceType: utils.MetaVoice,
Value: 5 * float64(time.Second),
Balance: map[string]interface{}{
utils.ID: "TestDynamicDebitBalance",
utils.RatingSubject: "*zero5ms",
},
}
var reply string
if err := srrpc.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Received: %s", reply)
}
t.Run("TestAddVoiceBalance", func(t *testing.T) {
testAccountBalance(t, sraccount, srtenant, utils.MetaVoice, 5*float64(time.Second))
})
}
// func testSrItAddVoiceBalance(t *testing.T) {
// attrSetBalance := utils.AttrSetBalance{
// Tenant: srtenant,
// Account: sraccount,
// BalanceType: utils.MetaVoice,
// Value: 5 * float64(time.Second),
// Balance: map[string]interface{}{
// utils.ID: "TestDynamicDebitBalance",
// utils.RatingSubject: "*zero5ms",
// },
// }
// var reply string
// if err := srrpc.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Received: %s", reply)
// }
// t.Run("TestAddVoiceBalance", func(t *testing.T) {
// testAccountBalance(t, sraccount, srtenant, utils.MetaVoice, 5*float64(time.Second))
// })
// }
func testSrItInitSession(t *testing.T) {
args1 := &sessions.V1InitSessionArgs{
InitSession: true,
// func testSrItInitSession(t *testing.T) {
// args1 := &sessions.V1InitSessionArgs{
// InitSession: true,
CGREvent: &utils.CGREvent{
Tenant: srtenant,
ID: "TestSrItInitiateSession",
Event: map[string]interface{}{
utils.Tenant: srtenant,
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestRefund",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: sraccount,
utils.Subject: "TEST",
utils.Destination: "TEST",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 2 * time.Second,
},
},
}
var rply1 sessions.V1InitSessionReply
if err := srrpc.Call(utils.SessionSv1InitiateSession,
args1, &rply1); err != nil {
t.Error(err)
return
} else if rply1.MaxUsage == nil || *rply1.MaxUsage != 2*time.Second {
t.Errorf("Unexpected MaxUsage: %v", rply1.MaxUsage)
}
t.Run("TestInitSession", func(t *testing.T) {
testAccountBalance(t, sraccount, srtenant, utils.MetaVoice, 3*float64(time.Second))
})
}
// CGREvent: &utils.CGREvent{
// Tenant: srtenant,
// ID: "TestSrItInitiateSession",
// Event: map[string]interface{}{
// utils.Tenant: srtenant,
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestRefund",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: sraccount,
// utils.Subject: "TEST",
// utils.Destination: "TEST",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 2 * time.Second,
// },
// },
// }
// var rply1 sessions.V1InitSessionReply
// if err := srrpc.Call(utils.SessionSv1InitiateSession,
// args1, &rply1); err != nil {
// t.Error(err)
// return
// } else if rply1.MaxUsage == nil || *rply1.MaxUsage != 2*time.Second {
// t.Errorf("Unexpected MaxUsage: %v", rply1.MaxUsage)
// }
// t.Run("TestInitSession", func(t *testing.T) {
// testAccountBalance(t, sraccount, srtenant, utils.MetaVoice, 3*float64(time.Second))
// })
// }
func testSrItTerminateSession(t *testing.T) {
args := &sessions.V1TerminateSessionArgs{
TerminateSession: true,
CGREvent: &utils.CGREvent{
Tenant: srtenant,
ID: "TestSrItUpdateSession",
Event: map[string]interface{}{
utils.Tenant: srtenant,
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestRefund",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: sraccount,
utils.Subject: "TEST",
utils.Destination: "TEST",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 0,
},
},
}
var rply string
if err := srrpc.Call(utils.SessionSv1TerminateSession,
args, &rply); err != nil {
t.Error(err)
}
if rply != utils.OK {
t.Errorf("Unexpected reply: %s", rply)
}
aSessions := make([]*sessions.ExternalSession, 0)
if err := srrpc.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
t.Run("TestTerminateSession", func(t *testing.T) {
testAccountBalance(t, sraccount, srtenant, utils.MetaVoice, 5*float64(time.Second))
})
}
// func testSrItTerminateSession(t *testing.T) {
// args := &sessions.V1TerminateSessionArgs{
// TerminateSession: true,
// CGREvent: &utils.CGREvent{
// Tenant: srtenant,
// ID: "TestSrItUpdateSession",
// Event: map[string]interface{}{
// utils.Tenant: srtenant,
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestRefund",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: sraccount,
// utils.Subject: "TEST",
// utils.Destination: "TEST",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 0,
// },
// },
// }
// var rply string
// if err := srrpc.Call(utils.SessionSv1TerminateSession,
// args, &rply); err != nil {
// t.Error(err)
// }
// if rply != utils.OK {
// t.Errorf("Unexpected reply: %s", rply)
// }
// aSessions := make([]*sessions.ExternalSession, 0)
// if err := srrpc.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// t.Run("TestTerminateSession", func(t *testing.T) {
// testAccountBalance(t, sraccount, srtenant, utils.MetaVoice, 5*float64(time.Second))
// })
// }
func testSrItAddMonetaryBalance(t *testing.T) {
sraccount += "2"
attrs := &utils.AttrSetBalance{
Tenant: srtenant,
Account: sraccount,
BalanceType: utils.MetaMonetary,
Value: 10.65,
Balance: map[string]interface{}{
utils.ID: utils.MetaDefault,
},
}
var reply string
if err := srrpc.Call(utils.APIerSv2SetBalance, attrs, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Received: %s", reply)
}
t.Run("TestAddMonetaryBalance", func(t *testing.T) { testAccountBalance(t, sraccount, srtenant, utils.MetaMonetary, 10.65) })
}
// func testSrItAddMonetaryBalance(t *testing.T) {
// sraccount += "2"
// attrs := &utils.AttrSetBalance{
// Tenant: srtenant,
// Account: sraccount,
// BalanceType: utils.MetaMonetary,
// Value: 10.65,
// Balance: map[string]interface{}{
// utils.ID: utils.MetaDefault,
// },
// }
// var reply string
// if err := srrpc.Call(utils.APIerSv2SetBalance, attrs, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Received: %s", reply)
// }
// t.Run("TestAddMonetaryBalance", func(t *testing.T) { testAccountBalance(t, sraccount, srtenant, utils.MetaMonetary, 10.65) })
// }
func testSrItInitSession2(t *testing.T) {
args1 := &sessions.V1InitSessionArgs{
InitSession: true,
// func testSrItInitSession2(t *testing.T) {
// args1 := &sessions.V1InitSessionArgs{
// InitSession: true,
CGREvent: &utils.CGREvent{
Tenant: srtenant,
ID: "TestSrItInitiateSession1",
Event: map[string]interface{}{
utils.Tenant: srtenant,
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestRefund",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: sraccount,
utils.Subject: "TEST",
utils.Destination: "1001",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 2 * time.Minute,
},
},
}
var rply1 sessions.V1InitSessionReply
if err := srrpc.Call(utils.SessionSv1InitiateSession,
args1, &rply1); err != nil {
t.Error(err)
return
} else if rply1.MaxUsage == nil || *rply1.MaxUsage != 2*time.Minute {
t.Errorf("Unexpected MaxUsage: %v", rply1.MaxUsage)
}
t.Run("TestInitSession", func(t *testing.T) { testAccountBalance(t, sraccount, srtenant, utils.MetaMonetary, 10.3002) })
}
// CGREvent: &utils.CGREvent{
// Tenant: srtenant,
// ID: "TestSrItInitiateSession1",
// Event: map[string]interface{}{
// utils.Tenant: srtenant,
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestRefund",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: sraccount,
// utils.Subject: "TEST",
// utils.Destination: "1001",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 2 * time.Minute,
// },
// },
// }
// var rply1 sessions.V1InitSessionReply
// if err := srrpc.Call(utils.SessionSv1InitiateSession,
// args1, &rply1); err != nil {
// t.Error(err)
// return
// } else if rply1.MaxUsage == nil || *rply1.MaxUsage != 2*time.Minute {
// t.Errorf("Unexpected MaxUsage: %v", rply1.MaxUsage)
// }
// t.Run("TestInitSession", func(t *testing.T) { testAccountBalance(t, sraccount, srtenant, utils.MetaMonetary, 10.3002) })
// }
func testSrItTerminateSession2(t *testing.T) {
args := &sessions.V1TerminateSessionArgs{
TerminateSession: true,
// func testSrItTerminateSession2(t *testing.T) {
// args := &sessions.V1TerminateSessionArgs{
// TerminateSession: true,
CGREvent: &utils.CGREvent{
Tenant: srtenant,
ID: "TestSrItUpdateSession",
Event: map[string]interface{}{
utils.Tenant: srtenant,
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestRefund",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: sraccount,
utils.Subject: "TEST",
utils.Destination: "1001",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 0,
},
},
}
var rply string
if err := srrpc.Call(utils.SessionSv1TerminateSession,
args, &rply); err != nil {
t.Error(err)
}
if rply != utils.OK {
t.Errorf("Unexpected reply: %s", rply)
}
aSessions := make([]*sessions.ExternalSession, 0)
if err := srrpc.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
t.Run("TestTerminateSession", func(t *testing.T) { testAccountBalance(t, sraccount, srtenant, utils.MetaMonetary, 10.65) })
}
// CGREvent: &utils.CGREvent{
// Tenant: srtenant,
// ID: "TestSrItUpdateSession",
// Event: map[string]interface{}{
// utils.Tenant: srtenant,
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestRefund",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: sraccount,
// utils.Subject: "TEST",
// utils.Destination: "1001",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: 0,
// },
// },
// }
// var rply string
// if err := srrpc.Call(utils.SessionSv1TerminateSession,
// args, &rply); err != nil {
// t.Error(err)
// }
// if rply != utils.OK {
// t.Errorf("Unexpected reply: %s", rply)
// }
// aSessions := make([]*sessions.ExternalSession, 0)
// if err := srrpc.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// t.Run("TestTerminateSession", func(t *testing.T) { testAccountBalance(t, sraccount, srtenant, utils.MetaMonetary, 10.65) })
// }
func testSrItStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSrItStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

920
general_tests/sessionroutes_it_test.go
View File

@@ -21,510 +21,510 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"reflect"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "reflect"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// )
var (
sesRoutesCfgDir string
sesRoutesCfgPath string
sesRoutesCfg *config.CGRConfig
sesRoutesRPC *rpc.Client
// var (
// sesRoutesCfgDir string
// sesRoutesCfgPath string
// sesRoutesCfg *config.CGRConfig
// sesRoutesRPC *rpc.Client
sesRoutesTests = []func(t *testing.T){
testSesRoutesItLoadConfig,
testSesRoutesItResetDataDB,
testSesRoutesItResetStorDb,
testSesRoutesItStartEngine,
testSesRoutesItRPCConn,
testSesRoutesItLoadFromFolder,
// sesRoutesTests = []func(t *testing.T){
// testSesRoutesItLoadConfig,
// testSesRoutesItResetDataDB,
// testSesRoutesItResetStorDb,
// testSesRoutesItStartEngine,
// testSesRoutesItRPCConn,
// testSesRoutesItLoadFromFolder,
testSesRoutesAuthorizeEvent,
testSesRoutesProcessMessage,
testSesRoutesProcessEvent,
// testSesRoutesAuthorizeEvent,
// testSesRoutesProcessMessage,
// testSesRoutesProcessEvent,
testSesRoutesItStopCgrEngine,
}
)
// testSesRoutesItStopCgrEngine,
// }
// )
func TestSesRoutesItSessions(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
sesRoutesCfgDir = "tutinternal"
case utils.MetaMySQL:
sesRoutesCfgDir = "tutmysql"
case utils.MetaMongo:
sesRoutesCfgDir = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sesRoutesTests {
t.Run(sesRoutesCfgDir, stest)
}
}
// func TestSesRoutesItSessions(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// sesRoutesCfgDir = "tutinternal"
// case utils.MetaMySQL:
// sesRoutesCfgDir = "tutmysql"
// case utils.MetaMongo:
// sesRoutesCfgDir = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sesRoutesTests {
// t.Run(sesRoutesCfgDir, stest)
// }
// }
func testSesRoutesItLoadConfig(t *testing.T) {
sesRoutesCfgPath = path.Join(*dataDir, "conf", "samples", sesRoutesCfgDir)
if sesRoutesCfg, err = config.NewCGRConfigFromPath(sesRoutesCfgPath); err != nil {
t.Error(err)
}
}
// func testSesRoutesItLoadConfig(t *testing.T) {
// sesRoutesCfgPath = path.Join(*dataDir, "conf", "samples", sesRoutesCfgDir)
// if sesRoutesCfg, err = config.NewCGRConfigFromPath(sesRoutesCfgPath); err != nil {
// t.Error(err)
// }
// }
func testSesRoutesItResetDataDB(t *testing.T) {
if err := engine.InitDataDB(sesRoutesCfg); err != nil {
t.Fatal(err)
}
}
// func testSesRoutesItResetDataDB(t *testing.T) {
// if err := engine.InitDataDB(sesRoutesCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSesRoutesItResetStorDb(t *testing.T) {
if err := engine.InitStorDB(sesRoutesCfg); err != nil {
t.Fatal(err)
}
}
// func testSesRoutesItResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(sesRoutesCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSesRoutesItStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(sesRoutesCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testSesRoutesItStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(sesRoutesCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testSesRoutesItRPCConn(t *testing.T) {
var err error
sesRoutesRPC, err = newRPCClient(sesRoutesCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testSesRoutesItRPCConn(t *testing.T) {
// var err error
// sesRoutesRPC, err = newRPCClient(sesRoutesCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testSesRoutesItLoadFromFolder(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")}
if err := sesRoutesRPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
}
time.Sleep(100 * time.Millisecond)
}
// func testSesRoutesItLoadFromFolder(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")}
// if err := sesRoutesRPC.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// }
// time.Sleep(100 * time.Millisecond)
// }
func testSesRoutesAuthorizeEvent(t *testing.T) {
cgrEv := &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
utils.Source: "testV4CDRsProcessCDR",
utils.OriginID: "testV4CDRsProcessCDR",
utils.OriginHost: "192.168.1.1",
utils.RequestType: utils.MetaPostpaid,
utils.Category: utils.Call,
utils.AccountField: "1003",
utils.Subject: "1003",
utils.Destination: "1002",
utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
utils.SetupTime: time.Date(2018, 8, 24, 16, 00, 00, 0, time.UTC),
utils.Usage: time.Minute,
},
APIOpts: map[string]interface{}{utils.OptsRoutesProfileCount: 1},
}
args := sessions.NewV1AuthorizeArgs(false, []string{},
false, []string{}, false, []string{}, false, false,
true, false, false, cgrEv, utils.Paginator{}, false, "")
// func testSesRoutesAuthorizeEvent(t *testing.T) {
// cgrEv := &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// utils.Source: "testV4CDRsProcessCDR",
// utils.OriginID: "testV4CDRsProcessCDR",
// utils.OriginHost: "192.168.1.1",
// utils.RequestType: utils.MetaPostpaid,
// utils.Category: utils.Call,
// utils.AccountField: "1003",
// utils.Subject: "1003",
// utils.Destination: "1002",
// utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
// utils.SetupTime: time.Date(2018, 8, 24, 16, 00, 00, 0, time.UTC),
// utils.Usage: time.Minute,
// },
// APIOpts: map[string]interface{}{utils.OptsRoutesProfileCount: 1},
// }
// args := sessions.NewV1AuthorizeArgs(false, []string{},
// false, []string{}, false, []string{}, false, false,
// true, false, false, cgrEv, utils.Paginator{}, false, "")
var rply sessions.V1AuthorizeReply
if err := sesRoutesRPC.Call(utils.SessionSv1AuthorizeEvent, args, &rply); err != nil {
t.Fatal(err)
}
expected := sessions.V1AuthorizeReply{
RouteProfiles: engine.SortedRoutesList{{
ProfileID: "ROUTE_LEASTCOST_1",
Sorting: "*lc",
Routes: []*engine.SortedRoute{
{
RouteID: "route3",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 15.,
},
}, {
RouteID: "route1",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 10.,
},
}, {
RouteID: "route2",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 1.2,
"RatingPlanID": "RP_RETAIL1",
"Weight": 20.,
},
},
},
},
}}
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
args = sessions.NewV1AuthorizeArgs(false, []string{},
false, []string{}, false, []string{}, false, false,
true, false, false, cgrEv, utils.Paginator{}, false, "2")
// var rply sessions.V1AuthorizeReply
// if err := sesRoutesRPC.Call(utils.SessionSv1AuthorizeEvent, args, &rply); err != nil {
// t.Fatal(err)
// }
// expected := sessions.V1AuthorizeReply{
// RouteProfiles: engine.SortedRoutesList{{
// ProfileID: "ROUTE_LEASTCOST_1",
// Sorting: "*lc",
// Routes: []*engine.SortedRoute{
// {
// RouteID: "route3",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 15.,
// },
// }, {
// RouteID: "route1",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 10.,
// },
// }, {
// RouteID: "route2",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 1.2,
// "RatingPlanID": "RP_RETAIL1",
// "Weight": 20.,
// },
// },
// },
// },
// }}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
// args = sessions.NewV1AuthorizeArgs(false, []string{},
// false, []string{}, false, []string{}, false, false,
// true, false, false, cgrEv, utils.Paginator{}, false, "2")
rply = sessions.V1AuthorizeReply{}
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
args, &rply); err != nil {
t.Fatal(err)
}
// rply = sessions.V1AuthorizeReply{}
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
// args, &rply); err != nil {
// t.Fatal(err)
// }
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
expected = sessions.V1AuthorizeReply{
RouteProfiles: engine.SortedRoutesList{{
ProfileID: "ROUTE_LEASTCOST_1",
Sorting: "*lc",
Routes: []*engine.SortedRoute{
{
RouteID: "route3",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 15.,
},
}, {
RouteID: "route1",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 10.,
},
},
},
},
}}
// expected = sessions.V1AuthorizeReply{
// RouteProfiles: engine.SortedRoutesList{{
// ProfileID: "ROUTE_LEASTCOST_1",
// Sorting: "*lc",
// Routes: []*engine.SortedRoute{
// {
// RouteID: "route3",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 15.,
// },
// }, {
// RouteID: "route1",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 10.,
// },
// },
// },
// },
// }}
args = sessions.NewV1AuthorizeArgs(false, []string{},
false, []string{}, false, []string{}, false, false,
true, false, false, cgrEv, utils.Paginator{}, false, "1")
// args = sessions.NewV1AuthorizeArgs(false, []string{},
// false, []string{}, false, []string{}, false, false,
// true, false, false, cgrEv, utils.Paginator{}, false, "1")
rply = sessions.V1AuthorizeReply{}
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
args, &rply); err != nil {
t.Fatal(err)
}
// rply = sessions.V1AuthorizeReply{}
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
// args, &rply); err != nil {
// t.Fatal(err)
// }
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
args = sessions.NewV1AuthorizeArgs(false, []string{},
false, []string{}, false, []string{}, false, false,
true, false, true, cgrEv, utils.Paginator{}, false, "")
// args = sessions.NewV1AuthorizeArgs(false, []string{},
// false, []string{}, false, []string{}, false, false,
// true, false, true, cgrEv, utils.Paginator{}, false, "")
rply = sessions.V1AuthorizeReply{}
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
args, &rply); err != nil {
t.Fatal(err)
}
// rply = sessions.V1AuthorizeReply{}
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
// args, &rply); err != nil {
// t.Fatal(err)
// }
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
// }
func testSesRoutesProcessMessage(t *testing.T) {
cgrEv := &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
utils.Source: "testV4CDRsProcessCDR",
utils.OriginID: "testV4CDRsProcessCDR",
utils.OriginHost: "192.168.1.1",
utils.RequestType: utils.MetaPostpaid,
utils.Category: utils.Call,
utils.AccountField: "1003",
utils.Subject: "1003",
utils.Destination: "1002",
utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
utils.SetupTime: time.Date(2018, 8, 24, 16, 00, 00, 0, time.UTC),
utils.Usage: time.Minute,
},
APIOpts: map[string]interface{}{utils.OptsRoutesProfileCount: 1},
}
args := sessions.NewV1ProcessMessageArgs(false, []string{},
false, []string{}, false, []string{}, false, false,
true, false, false, cgrEv, utils.Paginator{}, false, "")
// func testSesRoutesProcessMessage(t *testing.T) {
// cgrEv := &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// utils.Source: "testV4CDRsProcessCDR",
// utils.OriginID: "testV4CDRsProcessCDR",
// utils.OriginHost: "192.168.1.1",
// utils.RequestType: utils.MetaPostpaid,
// utils.Category: utils.Call,
// utils.AccountField: "1003",
// utils.Subject: "1003",
// utils.Destination: "1002",
// utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
// utils.SetupTime: time.Date(2018, 8, 24, 16, 00, 00, 0, time.UTC),
// utils.Usage: time.Minute,
// },
// APIOpts: map[string]interface{}{utils.OptsRoutesProfileCount: 1},
// }
// args := sessions.NewV1ProcessMessageArgs(false, []string{},
// false, []string{}, false, []string{}, false, false,
// true, false, false, cgrEv, utils.Paginator{}, false, "")
var rply sessions.V1ProcessMessageReply
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
args, &rply); err != nil {
t.Fatal(err)
}
expected := sessions.V1ProcessMessageReply{
RouteProfiles: engine.SortedRoutesList{{
ProfileID: "ROUTE_LEASTCOST_1",
Sorting: "*lc",
Routes: []*engine.SortedRoute{
{
RouteID: "route3",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 15.,
},
}, {
RouteID: "route1",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 10.,
},
}, {
RouteID: "route2",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 1.2,
"RatingPlanID": "RP_RETAIL1",
"Weight": 20.,
},
},
},
},
}}
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
// var rply sessions.V1ProcessMessageReply
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
// args, &rply); err != nil {
// t.Fatal(err)
// }
// expected := sessions.V1ProcessMessageReply{
// RouteProfiles: engine.SortedRoutesList{{
// ProfileID: "ROUTE_LEASTCOST_1",
// Sorting: "*lc",
// Routes: []*engine.SortedRoute{
// {
// RouteID: "route3",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 15.,
// },
// }, {
// RouteID: "route1",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 10.,
// },
// }, {
// RouteID: "route2",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 1.2,
// "RatingPlanID": "RP_RETAIL1",
// "Weight": 20.,
// },
// },
// },
// },
// }}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
args = sessions.NewV1ProcessMessageArgs(false, []string{},
false, []string{}, false, []string{}, false, false,
true, false, false, cgrEv, utils.Paginator{}, false, "2")
// args = sessions.NewV1ProcessMessageArgs(false, []string{},
// false, []string{}, false, []string{}, false, false,
// true, false, false, cgrEv, utils.Paginator{}, false, "2")
rply = sessions.V1ProcessMessageReply{}
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
args, &rply); err != nil {
t.Fatal(err)
}
// rply = sessions.V1ProcessMessageReply{}
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
// args, &rply); err != nil {
// t.Fatal(err)
// }
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
expected = sessions.V1ProcessMessageReply{
RouteProfiles: engine.SortedRoutesList{{
ProfileID: "ROUTE_LEASTCOST_1",
Sorting: "*lc",
Routes: []*engine.SortedRoute{
{
RouteID: "route3",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 15.,
},
}, {
RouteID: "route1",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 10.,
},
},
},
},
}}
// expected = sessions.V1ProcessMessageReply{
// RouteProfiles: engine.SortedRoutesList{{
// ProfileID: "ROUTE_LEASTCOST_1",
// Sorting: "*lc",
// Routes: []*engine.SortedRoute{
// {
// RouteID: "route3",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 15.,
// },
// }, {
// RouteID: "route1",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 10.,
// },
// },
// },
// },
// }}
args = sessions.NewV1ProcessMessageArgs(false, []string{},
false, []string{}, false, []string{}, false, false,
true, false, false, cgrEv, utils.Paginator{}, false, "1")
// args = sessions.NewV1ProcessMessageArgs(false, []string{},
// false, []string{}, false, []string{}, false, false,
// true, false, false, cgrEv, utils.Paginator{}, false, "1")
rply = sessions.V1ProcessMessageReply{}
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
args, &rply); err != nil {
t.Fatal(err)
}
// rply = sessions.V1ProcessMessageReply{}
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
// args, &rply); err != nil {
// t.Fatal(err)
// }
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
args = sessions.NewV1ProcessMessageArgs(false, []string{},
false, []string{}, false, []string{}, false, false,
true, false, true, cgrEv, utils.Paginator{}, false, "")
// args = sessions.NewV1ProcessMessageArgs(false, []string{},
// false, []string{}, false, []string{}, false, false,
// true, false, true, cgrEv, utils.Paginator{}, false, "")
rply = sessions.V1ProcessMessageReply{}
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
args, &rply); err != nil {
t.Fatal(err)
}
// rply = sessions.V1ProcessMessageReply{}
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessMessage,
// args, &rply); err != nil {
// t.Fatal(err)
// }
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
// }
func testSesRoutesProcessEvent(t *testing.T) {
cgrEv := &utils.CGREvent{
Tenant: "cgrates.org",
Event: map[string]interface{}{
utils.Source: "testV4CDRsProcessCDR",
utils.OriginID: "testV4CDRsProcessCDR",
utils.OriginHost: "192.168.1.1",
utils.RequestType: utils.MetaPostpaid,
utils.Category: utils.Call,
utils.AccountField: "1003",
utils.Subject: "1003",
utils.Destination: "1002",
utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
utils.SetupTime: time.Date(2018, 8, 24, 16, 00, 00, 0, time.UTC),
utils.Usage: time.Minute,
},
APIOpts: map[string]interface{}{utils.OptsRoutesProfileCount: 1},
}
args := sessions.V1ProcessEventArgs{
Flags: []string{"*routes"},
CGREvent: cgrEv,
Paginator: utils.Paginator{},
}
// func testSesRoutesProcessEvent(t *testing.T) {
// cgrEv := &utils.CGREvent{
// Tenant: "cgrates.org",
// Event: map[string]interface{}{
// utils.Source: "testV4CDRsProcessCDR",
// utils.OriginID: "testV4CDRsProcessCDR",
// utils.OriginHost: "192.168.1.1",
// utils.RequestType: utils.MetaPostpaid,
// utils.Category: utils.Call,
// utils.AccountField: "1003",
// utils.Subject: "1003",
// utils.Destination: "1002",
// utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC),
// utils.SetupTime: time.Date(2018, 8, 24, 16, 00, 00, 0, time.UTC),
// utils.Usage: time.Minute,
// },
// APIOpts: map[string]interface{}{utils.OptsRoutesProfileCount: 1},
// }
// args := sessions.V1ProcessEventArgs{
// Flags: []string{"*routes"},
// CGREvent: cgrEv,
// Paginator: utils.Paginator{},
// }
var rply sessions.V1ProcessEventReply
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessEvent, args, &rply); err != nil {
t.Fatal(err)
}
expected := sessions.V1ProcessEventReply{
RouteProfiles: map[string]engine.SortedRoutesList{
utils.MetaRaw: {{
ProfileID: "ROUTE_LEASTCOST_1",
Sorting: "*lc",
Routes: []*engine.SortedRoute{
{
RouteID: "route3",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 15.,
},
}, {
RouteID: "route1",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 10.,
},
}, {
RouteID: "route2",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 1.2,
"RatingPlanID": "RP_RETAIL1",
"Weight": 20.,
},
},
},
},
},
}}
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
// var rply sessions.V1ProcessEventReply
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessEvent, args, &rply); err != nil {
// t.Fatal(err)
// }
// expected := sessions.V1ProcessEventReply{
// RouteProfiles: map[string]engine.SortedRoutesList{
// utils.MetaRaw: {{
// ProfileID: "ROUTE_LEASTCOST_1",
// Sorting: "*lc",
// Routes: []*engine.SortedRoute{
// {
// RouteID: "route3",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 15.,
// },
// }, {
// RouteID: "route1",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 10.,
// },
// }, {
// RouteID: "route2",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 1.2,
// "RatingPlanID": "RP_RETAIL1",
// "Weight": 20.,
// },
// },
// },
// },
// },
// }}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
args = sessions.V1ProcessEventArgs{
Flags: []string{"*routes:*maxcost:2"},
CGREvent: cgrEv,
Paginator: utils.Paginator{},
}
// args = sessions.V1ProcessEventArgs{
// Flags: []string{"*routes:*maxcost:2"},
// CGREvent: cgrEv,
// Paginator: utils.Paginator{},
// }
rply = sessions.V1ProcessEventReply{}
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessEvent,
args, &rply); err != nil {
t.Fatal(err)
}
// rply = sessions.V1ProcessEventReply{}
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessEvent,
// args, &rply); err != nil {
// t.Fatal(err)
// }
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
expected = sessions.V1ProcessEventReply{
RouteProfiles: map[string]engine.SortedRoutesList{
utils.MetaRaw: {{
ProfileID: "ROUTE_LEASTCOST_1",
Sorting: "*lc",
Routes: []*engine.SortedRoute{
{
RouteID: "route3",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 15.,
},
}, {
RouteID: "route1",
RouteParameters: "",
SortingData: map[string]interface{}{
"Cost": 0.0102,
"RatingPlanID": "RP_SPECIAL_1002",
"Weight": 10.,
},
},
},
},
},
}}
// expected = sessions.V1ProcessEventReply{
// RouteProfiles: map[string]engine.SortedRoutesList{
// utils.MetaRaw: {{
// ProfileID: "ROUTE_LEASTCOST_1",
// Sorting: "*lc",
// Routes: []*engine.SortedRoute{
// {
// RouteID: "route3",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 15.,
// },
// }, {
// RouteID: "route1",
// RouteParameters: "",
// SortingData: map[string]interface{}{
// "Cost": 0.0102,
// "RatingPlanID": "RP_SPECIAL_1002",
// "Weight": 10.,
// },
// },
// },
// },
// },
// }}
args = sessions.V1ProcessEventArgs{
Flags: []string{"*routes:*maxcost:1"},
CGREvent: cgrEv,
Paginator: utils.Paginator{},
}
rply = sessions.V1ProcessEventReply{}
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessEvent,
args, &rply); err != nil {
t.Fatal(err)
}
// args = sessions.V1ProcessEventArgs{
// Flags: []string{"*routes:*maxcost:1"},
// CGREvent: cgrEv,
// Paginator: utils.Paginator{},
// }
// rply = sessions.V1ProcessEventReply{}
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessEvent,
// args, &rply); err != nil {
// t.Fatal(err)
// }
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
args = sessions.V1ProcessEventArgs{
Flags: []string{"*routes:*event_cost"},
CGREvent: cgrEv,
Paginator: utils.Paginator{},
}
// args = sessions.V1ProcessEventArgs{
// Flags: []string{"*routes:*event_cost"},
// CGREvent: cgrEv,
// Paginator: utils.Paginator{},
// }
rply = sessions.V1ProcessEventReply{}
if err := sesRoutesRPC.Call(utils.SessionSv1ProcessEvent,
args, &rply); err != nil {
t.Fatal(err)
}
// rply = sessions.V1ProcessEventReply{}
// if err := sesRoutesRPC.Call(utils.SessionSv1ProcessEvent,
// args, &rply); err != nil {
// t.Fatal(err)
// }
if !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
}
}
// if !reflect.DeepEqual(rply, expected) {
// t.Errorf("Expected: %s, received: %s", utils.ToJSON(expected), utils.ToJSON(rply))
// }
// }
func testSesRoutesItStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSesRoutesItStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

382
general_tests/sessions_tnt_change_cdr_it_test.go
View File

@@ -21,213 +21,213 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"reflect"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "reflect"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// )
var (
sesTntChngCdrsCfgDir string
sesTntChngCdrsCfgPath string
sesTntChngCdrsCfg *config.CGRConfig
sesTntChngCdrsRPC *rpc.Client
// var (
// sesTntChngCdrsCfgDir string
// sesTntChngCdrsCfgPath string
// sesTntChngCdrsCfg *config.CGRConfig
// sesTntChngCdrsRPC *rpc.Client
sesTntChngCdrsTests = []func(t *testing.T){
testSesTntChngCdrsLoadConfig,
testSesTntChngCdrsResetDataDB,
testSesTntChngCdrsResetStorDb,
testSesTntChngCdrsStartEngine,
testSesTntChngCdrsRPCConn,
testSesTntChngCdrsSetChargerProfile1,
testSesTntChngCdrsSetChargerProfile2,
testChargerSCdrsAuthProcessEventAuth,
testSesTntChngCdrsStopCgrEngine,
}
)
// sesTntChngCdrsTests = []func(t *testing.T){
// testSesTntChngCdrsLoadConfig,
// testSesTntChngCdrsResetDataDB,
// testSesTntChngCdrsResetStorDb,
// testSesTntChngCdrsStartEngine,
// testSesTntChngCdrsRPCConn,
// testSesTntChngCdrsSetChargerProfile1,
// testSesTntChngCdrsSetChargerProfile2,
// testChargerSCdrsAuthProcessEventAuth,
// testSesTntChngCdrsStopCgrEngine,
// }
// )
func TestSesCdrsTntChange(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
sesTntChngCfgDir = "tutinternal"
case utils.MetaMySQL:
sesTntChngCfgDir = "tutmysql"
case utils.MetaMongo:
sesTntChngCfgDir = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, sestest := range sesTntChngTests {
t.Run(sesTntChngCfgDir, sestest)
}
}
// func TestSesCdrsTntChange(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// sesTntChngCfgDir = "tutinternal"
// case utils.MetaMySQL:
// sesTntChngCfgDir = "tutmysql"
// case utils.MetaMongo:
// sesTntChngCfgDir = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, sestest := range sesTntChngTests {
// t.Run(sesTntChngCfgDir, sestest)
// }
// }
func testSesTntChngCdrsLoadConfig(t *testing.T) {
sesTntChngCfgPath = path.Join(*dataDir, "conf", "samples", sesTntChngCfgDir)
if sesTntChngCfg, err = config.NewCGRConfigFromPath(sesTntChngCfgPath); err != nil {
t.Error(err)
}
}
// func testSesTntChngCdrsLoadConfig(t *testing.T) {
// sesTntChngCfgPath = path.Join(*dataDir, "conf", "samples", sesTntChngCfgDir)
// if sesTntChngCfg, err = config.NewCGRConfigFromPath(sesTntChngCfgPath); err != nil {
// t.Error(err)
// }
// }
func testSesTntChngCdrsResetDataDB(t *testing.T) {
if err := engine.InitDataDb(sesTntChngCfg); err != nil {
t.Fatal(err)
}
}
// func testSesTntChngCdrsResetDataDB(t *testing.T) {
// if err := engine.InitDataDb(sesTntChngCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSesTntChngCdrsResetStorDb(t *testing.T) {
if err := engine.InitStorDb(sesTntChngCfg); err != nil {
t.Fatal(err)
}
}
// func testSesTntChngCdrsResetStorDb(t *testing.T) {
// if err := engine.InitStorDb(sesTntChngCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSesTntChngCdrsStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(sesTntChngCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testSesTntChngCdrsStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(sesTntChngCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testSesTntChngCdrsRPCConn(t *testing.T) {
var err error
sesTntChngRPC, err = newRPCClient(sesTntChngCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testSesTntChngCdrsRPCConn(t *testing.T) {
// var err error
// sesTntChngRPC, err = newRPCClient(sesTntChngCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testSesTntChngCdrsSetChargerProfile1(t *testing.T) {
var reply *engine.ChargerProfile
if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "Charger1"}, &reply); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Fatal(err)
}
chargerProfile := &v1.ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "Charger1",
RunID: utils.MetaDefault,
AttributeIDs: []string{"*constant:*tenant:cgrates.ro;*constant:*req.Account:1234"},
},
}
// func testSesTntChngCdrsSetChargerProfile1(t *testing.T) {
// var reply *engine.ChargerProfile
// if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "Charger1"}, &reply); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Fatal(err)
// }
// chargerProfile := &v1.ChargerWithAPIOpts{
// ChargerProfile: &engine.ChargerProfile{
// Tenant: "cgrates.org",
// ID: "Charger1",
// RunID: utils.MetaDefault,
// AttributeIDs: []string{"*constant:*tenant:cgrates.ro;*constant:*req.Account:1234"},
// },
// }
var result string
if err := sesTntChngRPC.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
// var result string
// if err := sesTntChngRPC.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "Charger1"}, &reply); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(chargerProfile.ChargerProfile, reply) {
t.Errorf("Expecting : %+v, received: %+v", chargerProfile.ChargerProfile, reply)
}
}
// if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "Charger1"}, &reply); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(chargerProfile.ChargerProfile, reply) {
// t.Errorf("Expecting : %+v, received: %+v", chargerProfile.ChargerProfile, reply)
// }
// }
func testSesTntChngCdrsSetChargerProfile2(t *testing.T) {
var reply *engine.ChargerProfile
if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "Charger2"}, &reply); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Fatal(err)
}
chargerProfile := &v1.ChargerWithAPIOpts{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "Charger2",
RunID: utils.MetaRaw,
AttributeIDs: []string{},
},
}
// func testSesTntChngCdrsSetChargerProfile2(t *testing.T) {
// var reply *engine.ChargerProfile
// if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "Charger2"}, &reply); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Fatal(err)
// }
// chargerProfile := &v1.ChargerWithAPIOpts{
// ChargerProfile: &engine.ChargerProfile{
// Tenant: "cgrates.org",
// ID: "Charger2",
// RunID: utils.MetaRaw,
// AttributeIDs: []string{},
// },
// }
var result string
if err := sesTntChngRPC.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
// var result string
// if err := sesTntChngRPC.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "Charger2"}, &reply); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(chargerProfile.ChargerProfile, reply) {
t.Errorf("Expecting : %+v, received: %+v", chargerProfile.ChargerProfile, reply)
}
}
// if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "Charger2"}, &reply); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(chargerProfile.ChargerProfile, reply) {
// t.Errorf("Expecting : %+v, received: %+v", chargerProfile.ChargerProfile, reply)
// }
// }
func testChargerSCdrsAuthProcessEventAuth(t *testing.T) {
attrSetBalance := utils.AttrSetBalance{
Tenant: "cgrates.org",
Account: "1001",
BalanceType: utils.MetaVoice,
Value: float64(2 * time.Minute),
Balance: map[string]interface{}{
utils.ID: "testSes",
utils.RatingSubject: "*zero1ms",
},
}
var reply string
if err := sesTntChngRPC.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Received: %s", reply)
}
// func testChargerSCdrsAuthProcessEventAuth(t *testing.T) {
// attrSetBalance := utils.AttrSetBalance{
// Tenant: "cgrates.org",
// Account: "1001",
// BalanceType: utils.MetaVoice,
// Value: float64(2 * time.Minute),
// Balance: map[string]interface{}{
// utils.ID: "testSes",
// utils.RatingSubject: "*zero1ms",
// },
// }
// var reply string
// if err := sesTntChngRPC.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Received: %s", reply)
// }
attrSetBalance2 := utils.AttrSetBalance{
Tenant: "cgrates.ro",
Account: "1234",
BalanceType: utils.MetaVoice,
Value: float64(2 * time.Minute),
Balance: map[string]interface{}{
utils.ID: "testSes",
utils.RatingSubject: "*zero1ms",
},
}
var reply2 string
if err := sesTntChngRPC.Call(utils.APIerSv2SetBalance, attrSetBalance2, &reply2); err != nil {
t.Error(err)
} else if reply2 != utils.OK {
t.Errorf("Received: %s", reply2)
}
// attrSetBalance2 := utils.AttrSetBalance{
// Tenant: "cgrates.ro",
// Account: "1234",
// BalanceType: utils.MetaVoice,
// Value: float64(2 * time.Minute),
// Balance: map[string]interface{}{
// utils.ID: "testSes",
// utils.RatingSubject: "*zero1ms",
// },
// }
// var reply2 string
// if err := sesTntChngRPC.Call(utils.APIerSv2SetBalance, attrSetBalance2, &reply2); err != nil {
// t.Error(err)
// } else if reply2 != utils.OK {
// t.Errorf("Received: %s", reply2)
// }
ev := &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestEv1",
Event: map[string]interface{}{
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestEv1",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1001",
utils.Subject: "1001",
utils.Destination: "1002",
utils.Usage: time.Minute,
},
}
var rply sessions.V1AuthorizeReply
if err := sesTntChngRPC.Call(utils.CDRsV1ProcessEvent, ev, &rply); err != nil {
t.Fatal(err)
}
expected := &sessions.V1AuthorizeReply{
MaxUsage: (*time.Duration)(utils.Int64Pointer(60000000000)),
}
if !reflect.DeepEqual(utils.ToJSON(&expected), utils.ToJSON(&rply)) {
t.Errorf("Expecting : %+v, received: %+v", utils.ToJSON(&expected), utils.ToJSON(&rply))
}
}
// ev := &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestEv1",
// Event: map[string]interface{}{
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestEv1",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: "1001",
// utils.Subject: "1001",
// utils.Destination: "1002",
// utils.Usage: time.Minute,
// },
// }
// var rply sessions.V1AuthorizeReply
// if err := sesTntChngRPC.Call(utils.CDRsV1ProcessEvent, ev, &rply); err != nil {
// t.Fatal(err)
// }
// expected := &sessions.V1AuthorizeReply{
// MaxUsage: (*time.Duration)(utils.Int64Pointer(60000000000)),
// }
// if !reflect.DeepEqual(utils.ToJSON(&expected), utils.ToJSON(&rply)) {
// t.Errorf("Expecting : %+v, received: %+v", utils.ToJSON(&expected), utils.ToJSON(&rply))
// }
// }
func testSesTntChngCdrsStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSesTntChngCdrsStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

384
general_tests/sessions_tnt_change_it_test.go
View File

@@ -21,214 +21,214 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"reflect"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "reflect"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// )
var (
sesTntChngCfgDir string
sesTntChngCfgPath string
sesTntChngCfg *config.CGRConfig
sesTntChngRPC *rpc.Client
// var (
// sesTntChngCfgDir string
// sesTntChngCfgPath string
// sesTntChngCfg *config.CGRConfig
// sesTntChngRPC *rpc.Client
sesTntChngTests = []func(t *testing.T){
testSesTntChngLoadConfig,
testSesTntChngResetDataDB,
testSesTntChngResetStorDb,
testSesTntChngStartEngine,
testSesTntChngRPCConn,
testSesTntChngSetChargerProfile1,
testSesTntChngSetChargerProfile2,
testChargerSAuthProcessEventAuth,
testSesTntChngStopCgrEngine,
}
)
// sesTntChngTests = []func(t *testing.T){
// testSesTntChngLoadConfig,
// testSesTntChngResetDataDB,
// testSesTntChngResetStorDb,
// testSesTntChngStartEngine,
// testSesTntChngRPCConn,
// testSesTntChngSetChargerProfile1,
// testSesTntChngSetChargerProfile2,
// testChargerSAuthProcessEventAuth,
// testSesTntChngStopCgrEngine,
// }
// )
func TestSesTntChange(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
sesTntChngCfgDir = "tutinternal"
case utils.MetaMySQL:
sesTntChngCfgDir = "tutmysql"
case utils.MetaMongo:
sesTntChngCfgDir = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, sestest := range sesTntChngTests {
t.Run(sesTntChngCfgDir, sestest)
}
}
// func TestSesTntChange(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// sesTntChngCfgDir = "tutinternal"
// case utils.MetaMySQL:
// sesTntChngCfgDir = "tutmysql"
// case utils.MetaMongo:
// sesTntChngCfgDir = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, sestest := range sesTntChngTests {
// t.Run(sesTntChngCfgDir, sestest)
// }
// }
func testSesTntChngLoadConfig(t *testing.T) {
sesTntChngCfgPath = path.Join(*dataDir, "conf", "samples", sesTntChngCfgDir)
if sesTntChngCfg, err = config.NewCGRConfigFromPath(sesTntChngCfgPath); err != nil {
t.Error(err)
}
}
// func testSesTntChngLoadConfig(t *testing.T) {
// sesTntChngCfgPath = path.Join(*dataDir, "conf", "samples", sesTntChngCfgDir)
// if sesTntChngCfg, err = config.NewCGRConfigFromPath(sesTntChngCfgPath); err != nil {
// t.Error(err)
// }
// }
func testSesTntChngResetDataDB(t *testing.T) {
if err := engine.InitDataDb(sesTntChngCfg); err != nil {
t.Fatal(err)
}
}
// func testSesTntChngResetDataDB(t *testing.T) {
// if err := engine.InitDataDb(sesTntChngCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSesTntChngResetStorDb(t *testing.T) {
if err := engine.InitStorDb(sesTntChngCfg); err != nil {
t.Fatal(err)
}
}
// func testSesTntChngResetStorDb(t *testing.T) {
// if err := engine.InitStorDb(sesTntChngCfg); err != nil {
// t.Fatal(err)
// }
// }
func testSesTntChngStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(sesTntChngCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// func testSesTntChngStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(sesTntChngCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testSesTntChngRPCConn(t *testing.T) {
var err error
sesTntChngRPC, err = newRPCClient(sesTntChngCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testSesTntChngRPCConn(t *testing.T) {
// var err error
// sesTntChngRPC, err = newRPCClient(sesTntChngCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testSesTntChngSetChargerProfile1(t *testing.T) {
var reply *engine.ChargerProfile
if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "Charger1"}, &reply); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Fatal(err)
}
chargerProfile := &v1.ChargerWithCache{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "Charger1",
RunID: utils.MetaDefault,
AttributeIDs: []string{"*constant:*tenant:cgrates.ro;*constant:*req.Account:1234"},
},
}
// func testSesTntChngSetChargerProfile1(t *testing.T) {
// var reply *engine.ChargerProfile
// if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "Charger1"}, &reply); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Fatal(err)
// }
// chargerProfile := &v1.ChargerWithCache{
// ChargerProfile: &engine.ChargerProfile{
// Tenant: "cgrates.org",
// ID: "Charger1",
// RunID: utils.MetaDefault,
// AttributeIDs: []string{"*constant:*tenant:cgrates.ro;*constant:*req.Account:1234"},
// },
// }
var result string
if err := sesTntChngRPC.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
// var result string
// if err := sesTntChngRPC.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "Charger1"}, &reply); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(chargerProfile.ChargerProfile, reply) {
t.Errorf("Expecting : %+v, received: %+v", chargerProfile.ChargerProfile, reply)
}
}
// if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "Charger1"}, &reply); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(chargerProfile.ChargerProfile, reply) {
// t.Errorf("Expecting : %+v, received: %+v", chargerProfile.ChargerProfile, reply)
// }
// }
func testSesTntChngSetChargerProfile2(t *testing.T) {
var reply *engine.ChargerProfile
if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "Charger2"}, &reply); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Fatal(err)
}
chargerProfile := &v1.ChargerWithCache{
ChargerProfile: &engine.ChargerProfile{
Tenant: "cgrates.org",
ID: "Charger2",
RunID: utils.MetaRaw,
AttributeIDs: []string{},
},
}
// func testSesTntChngSetChargerProfile2(t *testing.T) {
// var reply *engine.ChargerProfile
// if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "Charger2"}, &reply); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Fatal(err)
// }
// chargerProfile := &v1.ChargerWithCache{
// ChargerProfile: &engine.ChargerProfile{
// Tenant: "cgrates.org",
// ID: "Charger2",
// RunID: utils.MetaRaw,
// AttributeIDs: []string{},
// },
// }
var result string
if err := sesTntChngRPC.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
// var result string
// if err := sesTntChngRPC.Call(utils.AdminSv1SetChargerProfile, chargerProfile, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "Charger2"}, &reply); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(chargerProfile.ChargerProfile, reply) {
t.Errorf("Expecting : %+v, received: %+v", chargerProfile.ChargerProfile, reply)
}
}
// if err := sesTntChngRPC.Call(utils.APIerSv1GetChargerProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "Charger2"}, &reply); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(chargerProfile.ChargerProfile, reply) {
// t.Errorf("Expecting : %+v, received: %+v", chargerProfile.ChargerProfile, reply)
// }
// }
func testChargerSAuthProcessEventAuth(t *testing.T) {
attrSetBalance := utils.AttrSetBalance{
Tenant: "cgrates.org",
Account: "1001",
BalanceType: utils.VOICE,
Value: float64(2 * time.Minute),
Balance: map[string]interface{}{
utils.ID: "testSes",
utils.RatingSubject: "*zero1ms",
},
}
var reply string
if err := sesTntChngRPC.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Received: %s", reply)
}
// func testChargerSAuthProcessEventAuth(t *testing.T) {
// attrSetBalance := utils.AttrSetBalance{
// Tenant: "cgrates.org",
// Account: "1001",
// BalanceType: utils.VOICE,
// Value: float64(2 * time.Minute),
// Balance: map[string]interface{}{
// utils.ID: "testSes",
// utils.RatingSubject: "*zero1ms",
// },
// }
// var reply string
// if err := sesTntChngRPC.Call(utils.APIerSv2SetBalance, attrSetBalance, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Received: %s", reply)
// }
attrSetBalance2 := utils.AttrSetBalance{
Tenant: "cgrates.ro",
Account: "1234",
BalanceType: utils.VOICE,
Value: float64(2 * time.Minute),
Balance: map[string]interface{}{
utils.ID: "testSes",
utils.RatingSubject: "*zero1ms",
},
}
var reply2 string
if err := sesTntChngRPC.Call(utils.APIerSv2SetBalance, attrSetBalance2, &reply2); err != nil {
t.Error(err)
} else if reply2 != utils.OK {
t.Errorf("Received: %s", reply2)
}
// attrSetBalance2 := utils.AttrSetBalance{
// Tenant: "cgrates.ro",
// Account: "1234",
// BalanceType: utils.VOICE,
// Value: float64(2 * time.Minute),
// Balance: map[string]interface{}{
// utils.ID: "testSes",
// utils.RatingSubject: "*zero1ms",
// },
// }
// var reply2 string
// if err := sesTntChngRPC.Call(utils.APIerSv2SetBalance, attrSetBalance2, &reply2); err != nil {
// t.Error(err)
// } else if reply2 != utils.OK {
// t.Errorf("Received: %s", reply2)
// }
ev := &sessions.V1AuthorizeArgs{
GetMaxUsage: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestEv1",
Event: map[string]interface{}{
utils.ToR: utils.VOICE,
utils.OriginID: "TestEv1",
utils.RequestType: "*prepaid",
utils.Account: "1001",
utils.Subject: "1001",
utils.Destination: "1002",
utils.Usage: time.Minute,
},
},
}
var rply sessions.V1AuthorizeReply
if err := sesTntChngRPC.Call(utils.SessionSv1AuthorizeEvent, ev, &rply); err != nil {
t.Fatal(err)
}
expected := &sessions.V1AuthorizeReply{}
if !reflect.DeepEqual(utils.ToJSON(&expected), utils.ToJSON(&rply)) {
t.Errorf("Expecting : %T, received: %T", utils.ToJSON(&expected), utils.ToJSON(&rply))
}
}
// ev := &sessions.V1AuthorizeArgs{
// GetMaxUsage: true,
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestEv1",
// Event: map[string]interface{}{
// utils.ToR: utils.VOICE,
// utils.OriginID: "TestEv1",
// utils.RequestType: "*prepaid",
// utils.Account: "1001",
// utils.Subject: "1001",
// utils.Destination: "1002",
// utils.Usage: time.Minute,
// },
// },
// }
// var rply sessions.V1AuthorizeReply
// if err := sesTntChngRPC.Call(utils.SessionSv1AuthorizeEvent, ev, &rply); err != nil {
// t.Fatal(err)
// }
// expected := &sessions.V1AuthorizeReply{}
// if !reflect.DeepEqual(utils.ToJSON(&expected), utils.ToJSON(&rply)) {
// t.Errorf("Expecting : %T, received: %T", utils.ToJSON(&expected), utils.ToJSON(&rply))
// }
// }
func testSesTntChngStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testSesTntChngStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

272
general_tests/tls_it_test.go
View File

@@ -20,154 +20,154 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package general_tests
import (
"path"
"testing"
"time"
// import (
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/rpcclient"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/sessions"
// "github.com/cgrates/cgrates/utils"
// "github.com/cgrates/rpcclient"
// )
var (
tlsCfgPath string
tlsCfg *config.CGRConfig
tlsRpcClientJson *rpcclient.RPCClient
tlsRpcClientGob *rpcclient.RPCClient
tlsHTTPJson *rpcclient.RPCClient
tlsConfDIR string //run tests for specific configuration
tlsDelay int
// var (
// tlsCfgPath string
// tlsCfg *config.CGRConfig
// tlsRpcClientJson *rpcclient.RPCClient
// tlsRpcClientGob *rpcclient.RPCClient
// tlsHTTPJson *rpcclient.RPCClient
// tlsConfDIR string //run tests for specific configuration
// tlsDelay int
sTestsTLS = []func(t *testing.T){
testTLSLoadConfig,
testTLSInitDataDb,
testTLSStartEngine,
testTLSRpcConn,
testTLSPing,
testTLSStopEngine,
}
)
// sTestsTLS = []func(t *testing.T){
// testTLSLoadConfig,
// testTLSInitDataDb,
// testTLSStartEngine,
// testTLSRpcConn,
// testTLSPing,
// testTLSStopEngine,
// }
// )
// Test start here
func TestTLS(t *testing.T) {
tlsConfDIR = "tls"
for _, stest := range sTestsTLS {
t.Run(tlsConfDIR, stest)
}
}
// // Test start here
// func TestTLS(t *testing.T) {
// tlsConfDIR = "tls"
// for _, stest := range sTestsTLS {
// t.Run(tlsConfDIR, stest)
// }
// }
func testTLSLoadConfig(t *testing.T) {
var err error
tlsCfgPath = path.Join(*dataDir, "conf", "samples", tlsConfDIR)
if *encoding == utils.MetaGOB {
tlsCfgPath = path.Join(*dataDir, "conf", "samples", tlsConfDIR+"_gob")
}
if tlsCfg, err = config.NewCGRConfigFromPath(tlsCfgPath); err != nil {
t.Error(err)
}
tlsDelay = 2000
}
// func testTLSLoadConfig(t *testing.T) {
// var err error
// tlsCfgPath = path.Join(*dataDir, "conf", "samples", tlsConfDIR)
// if *encoding == utils.MetaGOB {
// tlsCfgPath = path.Join(*dataDir, "conf", "samples", tlsConfDIR+"_gob")
// }
// if tlsCfg, err = config.NewCGRConfigFromPath(tlsCfgPath); err != nil {
// t.Error(err)
// }
// tlsDelay = 2000
// }
func testTLSInitDataDb(t *testing.T) {
if err := engine.InitDataDB(tlsCfg); err != nil {
t.Fatal(err)
}
}
// func testTLSInitDataDb(t *testing.T) {
// if err := engine.InitDataDB(tlsCfg); err != nil {
// t.Fatal(err)
// }
// }
func testTLSStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(tlsCfgPath, tlsDelay); err != nil {
t.Fatal(err)
}
}
// func testTLSStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(tlsCfgPath, tlsDelay); err != nil {
// t.Fatal(err)
// }
// }
func testTLSRpcConn(t *testing.T) {
var err error
tlsRpcClientJson, err = rpcclient.NewRPCClient(utils.TCP, "localhost:2022", true, tlsCfg.TLSCfg().ClientKey,
tlsCfg.TLSCfg().ClientCerificate, tlsCfg.TLSCfg().CaCertificate, 3, 3,
time.Second, 5*time.Minute, rpcclient.JSONrpc, nil, false, nil)
if err != nil {
t.Errorf("Error: %s when dialing", err)
}
// func testTLSRpcConn(t *testing.T) {
// var err error
// tlsRpcClientJson, err = rpcclient.NewRPCClient(utils.TCP, "localhost:2022", true, tlsCfg.TLSCfg().ClientKey,
// tlsCfg.TLSCfg().ClientCerificate, tlsCfg.TLSCfg().CaCertificate, 3, 3,
// time.Second, 5*time.Minute, rpcclient.JSONrpc, nil, false, nil)
// if err != nil {
// t.Errorf("Error: %s when dialing", err)
// }
tlsRpcClientGob, err = rpcclient.NewRPCClient(utils.TCP, "localhost:2023", true, tlsCfg.TLSCfg().ClientKey,
tlsCfg.TLSCfg().ClientCerificate, tlsCfg.TLSCfg().CaCertificate, 3, 3,
time.Second, 5*time.Minute, rpcclient.GOBrpc, nil, false, nil)
if err != nil {
t.Errorf("Error: %s when dialing", err)
}
// tlsRpcClientGob, err = rpcclient.NewRPCClient(utils.TCP, "localhost:2023", true, tlsCfg.TLSCfg().ClientKey,
// tlsCfg.TLSCfg().ClientCerificate, tlsCfg.TLSCfg().CaCertificate, 3, 3,
// time.Second, 5*time.Minute, rpcclient.GOBrpc, nil, false, nil)
// if err != nil {
// t.Errorf("Error: %s when dialing", err)
// }
tlsHTTPJson, err = rpcclient.NewRPCClient(utils.TCP, "https://localhost:2280/jsonrpc", true, tlsCfg.TLSCfg().ClientKey,
tlsCfg.TLSCfg().ClientCerificate, tlsCfg.TLSCfg().CaCertificate, 3, 3,
time.Second, 5*time.Minute, rpcclient.HTTPjson, nil, false, nil)
if err != nil {
t.Errorf("Error: %s when dialing", err)
}
}
// tlsHTTPJson, err = rpcclient.NewRPCClient(utils.TCP, "https://localhost:2280/jsonrpc", true, tlsCfg.TLSCfg().ClientKey,
// tlsCfg.TLSCfg().ClientCerificate, tlsCfg.TLSCfg().CaCertificate, 3, 3,
// time.Second, 5*time.Minute, rpcclient.HTTPjson, nil, false, nil)
// if err != nil {
// t.Errorf("Error: %s when dialing", err)
// }
// }
func testTLSPing(t *testing.T) {
var reply string
// func testTLSPing(t *testing.T) {
// var reply string
if err := tlsRpcClientJson.Call(utils.ThresholdSv1Ping, new(utils.CGREvent), &reply); err != nil {
t.Error(err)
} else if reply != utils.Pong {
t.Errorf("Received: %s", reply)
}
if err := tlsRpcClientGob.Call(utils.ThresholdSv1Ping, new(utils.CGREvent), &reply); err != nil {
t.Error(err)
} else if reply != utils.Pong {
t.Errorf("Received: %s", reply)
}
if err := tlsHTTPJson.Call(utils.ThresholdSv1Ping, new(utils.CGREvent), &reply); err != nil {
t.Error(err)
} else if reply != utils.Pong {
t.Errorf("Received: %s", reply)
}
if err := tlsRpcClientJson.Call(utils.DispatcherSv1Ping, "", &reply); err == nil {
t.Error(err)
}
if err := tlsRpcClientGob.Call(utils.DispatcherSv1Ping, "", &reply); err == nil {
t.Error(err)
}
if err := tlsHTTPJson.Call(utils.DispatcherSv1Ping, "", &reply); err == nil {
t.Error(err)
}
// if err := tlsRpcClientJson.Call(utils.ThresholdSv1Ping, new(utils.CGREvent), &reply); err != nil {
// t.Error(err)
// } else if reply != utils.Pong {
// t.Errorf("Received: %s", reply)
// }
// if err := tlsRpcClientGob.Call(utils.ThresholdSv1Ping, new(utils.CGREvent), &reply); err != nil {
// t.Error(err)
// } else if reply != utils.Pong {
// t.Errorf("Received: %s", reply)
// }
// if err := tlsHTTPJson.Call(utils.ThresholdSv1Ping, new(utils.CGREvent), &reply); err != nil {
// t.Error(err)
// } else if reply != utils.Pong {
// t.Errorf("Received: %s", reply)
// }
// if err := tlsRpcClientJson.Call(utils.DispatcherSv1Ping, "", &reply); err == nil {
// t.Error(err)
// }
// if err := tlsRpcClientGob.Call(utils.DispatcherSv1Ping, "", &reply); err == nil {
// t.Error(err)
// }
// if err := tlsHTTPJson.Call(utils.DispatcherSv1Ping, "", &reply); err == nil {
// t.Error(err)
// }
initUsage := 5 * time.Minute
args := &sessions.V1InitSessionArgs{
InitSession: true,
AllocateResources: true,
GetAttributes: true,
// initUsage := 5 * time.Minute
// args := &sessions.V1InitSessionArgs{
// InitSession: true,
// AllocateResources: true,
// GetAttributes: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: "TestSSv1ItInitiateSession",
Event: map[string]interface{}{
utils.Tenant: "cgrates.org",
utils.Category: "call",
utils.ToR: utils.MetaVoice,
utils.OriginID: "TestSSv1It1",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1001",
utils.Subject: "ANY2CNT",
utils.Destination: "1002",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: initUsage,
},
},
}
var rply sessions.V1InitReplyWithDigest
if err := tlsHTTPJson.Call(utils.SessionSv1InitiateSessionWithDigest,
args, &rply); err == nil {
t.Error(err)
}
}
// CGREvent: &utils.CGREvent{
// Tenant: "cgrates.org",
// ID: "TestSSv1ItInitiateSession",
// Event: map[string]interface{}{
// utils.Tenant: "cgrates.org",
// utils.Category: "call",
// utils.ToR: utils.MetaVoice,
// utils.OriginID: "TestSSv1It1",
// utils.RequestType: utils.MetaPrepaid,
// utils.AccountField: "1001",
// utils.Subject: "ANY2CNT",
// utils.Destination: "1002",
// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
// utils.Usage: initUsage,
// },
// },
// }
// var rply sessions.V1InitReplyWithDigest
// if err := tlsHTTPJson.Call(utils.SessionSv1InitiateSessionWithDigest,
// args, &rply); err == nil {
// t.Error(err)
// }
// }
func testTLSStopEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testTLSStopEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

806
general_tests/tp_it_test.go
View File

@@ -21,426 +21,426 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
tpCfgPath string
tpCfgDIR string
tpCfg *config.CGRConfig
tpRPC *rpc.Client
tpLoadInst utils.LoadInstance // Share load information between tests
// var (
// tpCfgPath string
// tpCfgDIR string
// tpCfg *config.CGRConfig
// tpRPC *rpc.Client
// tpLoadInst utils.LoadInstance // Share load information between tests
sTestTp = []func(t *testing.T){
testTpInitCfg,
testTpResetDataDb,
testTpResetStorDb,
testTpStartEngine,
testTpRpcConn,
testTpLoadTariffPlanFromFolder,
testTpBalanceCounter,
testTpActionTriggers,
testTpZeroCost,
testTpZeroNegativeCost,
testTpExecuteActionCgrRpc,
testTpExecuteActionCgrRpcAcc,
//testTpExecuteActionCgrRpcCdrStats,
testTpCreateExecuteActionMatch,
testTpSetRemoveActions,
testTpRemoveActionsRefenced,
testTpApierResetAccountActionTriggers,
testTpStopCgrEngine,
}
)
// sTestTp = []func(t *testing.T){
// testTpInitCfg,
// testTpResetDataDb,
// testTpResetStorDb,
// testTpStartEngine,
// testTpRpcConn,
// testTpLoadTariffPlanFromFolder,
// testTpBalanceCounter,
// testTpActionTriggers,
// testTpZeroCost,
// testTpZeroNegativeCost,
// testTpExecuteActionCgrRpc,
// testTpExecuteActionCgrRpcAcc,
// //testTpExecuteActionCgrRpcCdrStats,
// testTpCreateExecuteActionMatch,
// testTpSetRemoveActions,
// testTpRemoveActionsRefenced,
// testTpApierResetAccountActionTriggers,
// testTpStopCgrEngine,
// }
// )
func TestTp(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
tpCfgDIR = "tutinternal"
case utils.MetaMySQL:
tpCfgDIR = "tutmysql"
case utils.MetaMongo:
tpCfgDIR = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestTp {
t.Run(tpCfgDIR, stest)
}
}
func testTpInitCfg(t *testing.T) {
tpCfgPath = path.Join(*dataDir, "conf", "samples", tpCfgDIR)
// Init config first
var err error
tpCfg, err = config.NewCGRConfigFromPath(tpCfgPath)
if err != nil {
t.Error(err)
}
}
// func TestTp(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// tpCfgDIR = "tutinternal"
// case utils.MetaMySQL:
// tpCfgDIR = "tutmysql"
// case utils.MetaMongo:
// tpCfgDIR = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sTestTp {
// t.Run(tpCfgDIR, stest)
// }
// }
// func testTpInitCfg(t *testing.T) {
// tpCfgPath = path.Join(*dataDir, "conf", "samples", tpCfgDIR)
// // Init config first
// var err error
// tpCfg, err = config.NewCGRConfigFromPath(tpCfgPath)
// if err != nil {
// t.Error(err)
// }
// }
// Remove data in both rating and accounting db
func testTpResetDataDb(t *testing.T) {
if err := engine.InitDataDB(tpCfg); err != nil {
t.Fatal(err)
}
}
// // Remove data in both rating and accounting db
// func testTpResetDataDb(t *testing.T) {
// if err := engine.InitDataDB(tpCfg); err != nil {
// t.Fatal(err)
// }
// }
// Wipe out the cdr database
func testTpResetStorDb(t *testing.T) {
if err := engine.InitStorDB(tpCfg); err != nil {
t.Fatal(err)
}
}
// // Wipe out the cdr database
// func testTpResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(tpCfg); err != nil {
// t.Fatal(err)
// }
// }
// Start CGR Engine
func testTpStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(tpCfgPath, 1000); err != nil {
t.Fatal(err)
}
}
// // Start CGR Engine
// func testTpStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(tpCfgPath, 1000); err != nil {
// t.Fatal(err)
// }
// }
// Connect rpc client to rater
func testTpRpcConn(t *testing.T) {
var err error
tpRPC, err = newRPCClient(tpCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal(err)
}
}
// // Connect rpc client to rater
// func testTpRpcConn(t *testing.T) {
// var err error
// tpRPC, err = newRPCClient(tpCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal(err)
// }
// }
// Load the tariff plan, creating accounts and their balances
func testTpLoadTariffPlanFromFolder(t *testing.T) {
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testtp")}
if err := tpRPC.Call(utils.APIerSv2LoadTariffPlanFromFolder, attrs, &tpLoadInst); err != nil {
t.Error(err)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups
}
// // Load the tariff plan, creating accounts and their balances
// func testTpLoadTariffPlanFromFolder(t *testing.T) {
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testtp")}
// if err := tpRPC.Call(utils.APIerSv2LoadTariffPlanFromFolder, attrs, &tpLoadInst); err != nil {
// t.Error(err)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups
// }
func testTpBalanceCounter(t *testing.T) {
tStart := time.Date(2016, 3, 31, 0, 0, 0, 0, time.UTC)
cd := &engine.CallDescriptorWithAPIOpts{
CallDescriptor: &engine.CallDescriptor{
Category: "call",
Tenant: "cgrates.org",
Subject: "1001",
Destination: "+49",
DurationIndex: 0,
TimeStart: tStart,
TimeEnd: tStart.Add(20 * time.Second),
},
}
var cc engine.CallCost
if err := tpRPC.Call(utils.ResponderDebit, cd, &cc); err != nil {
t.Error("Got error on Responder.GetCost: ", err.Error())
} else if cc.GetDuration() != 20*time.Second {
t.Errorf("Calling Responder.MaxDebit got callcost: %v", cc.GetDuration())
}
var acnt *engine.Account
attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"}
if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
} else if acnt.UnitCounters[utils.MetaMonetary][1].Counters[0].Value != 20.0 {
t.Errorf("Calling APIerSv2.GetBalance received: %s", utils.ToIJSON(acnt))
}
}
// func testTpBalanceCounter(t *testing.T) {
// tStart := time.Date(2016, 3, 31, 0, 0, 0, 0, time.UTC)
// cd := &engine.CallDescriptorWithAPIOpts{
// CallDescriptor: &engine.CallDescriptor{
// Category: "call",
// Tenant: "cgrates.org",
// Subject: "1001",
// Destination: "+49",
// DurationIndex: 0,
// TimeStart: tStart,
// TimeEnd: tStart.Add(20 * time.Second),
// },
// }
// var cc engine.CallCost
// if err := tpRPC.Call(utils.ResponderDebit, cd, &cc); err != nil {
// t.Error("Got error on Responder.GetCost: ", err.Error())
// } else if cc.GetDuration() != 20*time.Second {
// t.Errorf("Calling Responder.MaxDebit got callcost: %v", cc.GetDuration())
// }
// var acnt *engine.Account
// attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"}
// if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
// } else if acnt.UnitCounters[utils.MetaMonetary][1].Counters[0].Value != 20.0 {
// t.Errorf("Calling APIerSv2.GetBalance received: %s", utils.ToIJSON(acnt))
// }
// }
func testTpActionTriggers(t *testing.T) {
var atrs engine.ActionTriggers
if err := tpRPC.Call(utils.APIerSv1GetActionTriggers, &v1.AttrGetActionTriggers{GroupIDs: []string{}}, &atrs); err != nil {
t.Error("Got error on APIerSv1.GetActionTriggers: ", err.Error())
} else if len(atrs) != 4 {
t.Errorf("Calling v1.GetActionTriggers got: %v", atrs)
}
var reply string
if err := tpRPC.Call(utils.APIerSv1SetActionTrigger, v1.AttrSetActionTrigger{
GroupID: "TestATR",
UniqueID: "Unique atr id",
ActionTrigger: map[string]interface{}{
utils.BalanceID: utils.StringPointer("BID1"),
},
}, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Calling v1.SetActionTrigger got: %v", reply)
}
if err := tpRPC.Call(utils.APIerSv1GetActionTriggers, &v1.AttrGetActionTriggers{GroupIDs: []string{}}, &atrs); err != nil {
t.Error(err)
} else if len(atrs) != 5 {
t.Errorf("Calling v1.GetActionTriggers got: %v", atrs)
}
if err := tpRPC.Call(utils.APIerSv1GetActionTriggers, &v1.AttrGetActionTriggers{GroupIDs: []string{"TestATR"}}, &atrs); err != nil {
t.Error("Got error on APIerSv1.GetActionTriggers: ", err.Error())
} else if len(atrs) != 1 {
t.Errorf("Calling v1.GetActionTriggers got: %v", atrs)
}
if atrs == nil {
t.Errorf("Expecting atrs to not be nil")
// atrs shoud not be nil so exit function
// to avoid nil segmentation fault;
// if this happens try to run this test manualy
return
}
if atrs[0].ID != "TestATR" ||
atrs[0].UniqueID != "Unique atr id" ||
*atrs[0].Balance.ID != "BID1" {
t.Error("Wrong action trigger set: ", utils.ToIJSON(atrs[0]))
}
}
// func testTpActionTriggers(t *testing.T) {
// var atrs engine.ActionTriggers
// if err := tpRPC.Call(utils.APIerSv1GetActionTriggers, &v1.AttrGetActionTriggers{GroupIDs: []string{}}, &atrs); err != nil {
// t.Error("Got error on APIerSv1.GetActionTriggers: ", err.Error())
// } else if len(atrs) != 4 {
// t.Errorf("Calling v1.GetActionTriggers got: %v", atrs)
// }
// var reply string
// if err := tpRPC.Call(utils.APIerSv1SetActionTrigger, v1.AttrSetActionTrigger{
// GroupID: "TestATR",
// UniqueID: "Unique atr id",
// ActionTrigger: map[string]interface{}{
// utils.BalanceID: utils.StringPointer("BID1"),
// },
// }, &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Errorf("Calling v1.SetActionTrigger got: %v", reply)
// }
// if err := tpRPC.Call(utils.APIerSv1GetActionTriggers, &v1.AttrGetActionTriggers{GroupIDs: []string{}}, &atrs); err != nil {
// t.Error(err)
// } else if len(atrs) != 5 {
// t.Errorf("Calling v1.GetActionTriggers got: %v", atrs)
// }
// if err := tpRPC.Call(utils.APIerSv1GetActionTriggers, &v1.AttrGetActionTriggers{GroupIDs: []string{"TestATR"}}, &atrs); err != nil {
// t.Error("Got error on APIerSv1.GetActionTriggers: ", err.Error())
// } else if len(atrs) != 1 {
// t.Errorf("Calling v1.GetActionTriggers got: %v", atrs)
// }
// if atrs == nil {
// t.Errorf("Expecting atrs to not be nil")
// // atrs shoud not be nil so exit function
// // to avoid nil segmentation fault;
// // if this happens try to run this test manualy
// return
// }
// if atrs[0].ID != "TestATR" ||
// atrs[0].UniqueID != "Unique atr id" ||
// *atrs[0].Balance.ID != "BID1" {
// t.Error("Wrong action trigger set: ", utils.ToIJSON(atrs[0]))
// }
// }
func testTpZeroCost(t *testing.T) {
var acnt *engine.Account
attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1012"}
if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
}
if acnt == nil {
t.Errorf("Expecting acnt to not be nil")
// acnt shoud not be nil so exit function
// to avoid nil segmentation fault;
// if this happens try to run this test manualy
return
}
balanceValueBefore := acnt.BalanceMap[utils.MetaMonetary][0].Value
tStart := time.Date(2016, 3, 31, 0, 0, 0, 0, time.UTC)
cd := &engine.CallDescriptorWithAPIOpts{
CallDescriptor: &engine.CallDescriptor{
Category: "call",
Tenant: "cgrates.org",
Subject: "free",
Account: "1012",
Destination: "+49",
DurationIndex: 0,
TimeStart: tStart,
TimeEnd: tStart.Add(20 * time.Second),
},
}
var cc engine.CallCost
if err := tpRPC.Call(utils.ResponderDebit, cd, &cc); err != nil {
t.Error("Got error on Responder.Debit: ", err.Error())
} else if cc.GetDuration() != 20*time.Second {
t.Errorf("Calling Responder.MaxDebit got callcost: %v", utils.ToIJSON(cc))
}
if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
} else if acnt.BalanceMap[utils.MetaMonetary][0].Value != balanceValueBefore {
t.Errorf("Calling APIerSv2.GetAccount received: %s", utils.ToIJSON(acnt))
}
}
// func testTpZeroCost(t *testing.T) {
// var acnt *engine.Account
// attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1012"}
// if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
// }
// if acnt == nil {
// t.Errorf("Expecting acnt to not be nil")
// // acnt shoud not be nil so exit function
// // to avoid nil segmentation fault;
// // if this happens try to run this test manualy
// return
// }
// balanceValueBefore := acnt.BalanceMap[utils.MetaMonetary][0].Value
// tStart := time.Date(2016, 3, 31, 0, 0, 0, 0, time.UTC)
// cd := &engine.CallDescriptorWithAPIOpts{
// CallDescriptor: &engine.CallDescriptor{
// Category: "call",
// Tenant: "cgrates.org",
// Subject: "free",
// Account: "1012",
// Destination: "+49",
// DurationIndex: 0,
// TimeStart: tStart,
// TimeEnd: tStart.Add(20 * time.Second),
// },
// }
// var cc engine.CallCost
// if err := tpRPC.Call(utils.ResponderDebit, cd, &cc); err != nil {
// t.Error("Got error on Responder.Debit: ", err.Error())
// } else if cc.GetDuration() != 20*time.Second {
// t.Errorf("Calling Responder.MaxDebit got callcost: %v", utils.ToIJSON(cc))
// }
// if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
// } else if acnt.BalanceMap[utils.MetaMonetary][0].Value != balanceValueBefore {
// t.Errorf("Calling APIerSv2.GetAccount received: %s", utils.ToIJSON(acnt))
// }
// }
func testTpZeroNegativeCost(t *testing.T) {
tStart := time.Date(2016, 3, 31, 0, 0, 0, 0, time.UTC)
cd := &engine.CallDescriptorWithAPIOpts{
CallDescriptor: &engine.CallDescriptor{
Category: "call",
Tenant: "cgrates.org",
Subject: "free",
Account: "1013",
Destination: "+4915",
DurationIndex: 0,
TimeStart: tStart,
TimeEnd: tStart.Add(20 * time.Second),
},
}
var cc engine.CallCost
if err := tpRPC.Call(utils.ResponderDebit, cd, &cc); err != nil {
t.Error("Got error on Responder.GetCost: ", err.Error())
} else if cc.GetDuration() != 20*time.Second {
t.Errorf("Calling Responder.MaxDebit got callcost: %v", utils.ToIJSON(cc))
}
var acnt engine.Account
attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1013"}
if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
} else if acnt.BalanceMap[utils.MetaVoice][0].Value != 100.0 {
t.Errorf("Calling APIerSv2.GetAccount received: %s", utils.ToIJSON(acnt))
}
}
// func testTpZeroNegativeCost(t *testing.T) {
// tStart := time.Date(2016, 3, 31, 0, 0, 0, 0, time.UTC)
// cd := &engine.CallDescriptorWithAPIOpts{
// CallDescriptor: &engine.CallDescriptor{
// Category: "call",
// Tenant: "cgrates.org",
// Subject: "free",
// Account: "1013",
// Destination: "+4915",
// DurationIndex: 0,
// TimeStart: tStart,
// TimeEnd: tStart.Add(20 * time.Second),
// },
// }
// var cc engine.CallCost
// if err := tpRPC.Call(utils.ResponderDebit, cd, &cc); err != nil {
// t.Error("Got error on Responder.GetCost: ", err.Error())
// } else if cc.GetDuration() != 20*time.Second {
// t.Errorf("Calling Responder.MaxDebit got callcost: %v", utils.ToIJSON(cc))
// }
// var acnt engine.Account
// attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1013"}
// if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
// } else if acnt.BalanceMap[utils.MetaVoice][0].Value != 100.0 {
// t.Errorf("Calling APIerSv2.GetAccount received: %s", utils.ToIJSON(acnt))
// }
// }
func testTpExecuteActionCgrRpc(t *testing.T) {
var reply string
if err := tpRPC.Call(utils.APIerSv2ExecuteAction, utils.AttrExecuteAction{ActionsId: "RPC"}, &reply); err != nil {
t.Error("Got error on APIerSv2.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: "1013"}
if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
}
}
// func testTpExecuteActionCgrRpc(t *testing.T) {
// var reply string
// if err := tpRPC.Call(utils.APIerSv2ExecuteAction, utils.AttrExecuteAction{ActionsId: "RPC"}, &reply); err != nil {
// t.Error("Got error on APIerSv2.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: "1013"}
// if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
// }
// }
func testTpExecuteActionCgrRpcAcc(t *testing.T) {
var reply string
if err := tpRPC.Call(utils.APIerSv2ExecuteAction, utils.AttrExecuteAction{
Tenant: "cgrates.org",
Account: "1016",
ActionsId: "RPC_DEST",
}, &reply); err != nil {
t.Error("Got error on APIerSv2.ExecuteAction: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling ExecuteAction got reply: %s", reply)
}
var dests []*engine.Destination
attrs := &v2.AttrGetDestinations{DestinationIDs: []string{}}
if err := tpRPC.Call(utils.APIerSv2GetDestinations, attrs, &dests); err != nil {
t.Error("Got error on APIerSv2.GetDestinations: ", err.Error())
}
}
// func testTpExecuteActionCgrRpcAcc(t *testing.T) {
// var reply string
// if err := tpRPC.Call(utils.APIerSv2ExecuteAction, utils.AttrExecuteAction{
// Tenant: "cgrates.org",
// Account: "1016",
// ActionsId: "RPC_DEST",
// }, &reply); err != nil {
// t.Error("Got error on APIerSv2.ExecuteAction: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling ExecuteAction got reply: %s", reply)
// }
// var dests []*engine.Destination
// attrs := &v2.AttrGetDestinations{DestinationIDs: []string{}}
// if err := tpRPC.Call(utils.APIerSv2GetDestinations, attrs, &dests); err != nil {
// t.Error("Got error on APIerSv2.GetDestinations: ", err.Error())
// }
// }
func testTpCreateExecuteActionMatch(t *testing.T) {
var reply string
if err := tpRPC.Call(utils.APIerSv2SetActions, &utils.AttrSetActions{
ActionsId: "PAYMENT_2056bd2fe137082970f97102b64e42fd",
Actions: []*utils.TPAction{
{
BalanceType: "*monetary",
Identifier: "*topup",
RatingSubject: "",
Units: "10.500000",
Weight: 10,
},
},
}, &reply); err != nil {
t.Error("Got error on APIerSv2.SetActions: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.SetActions got reply: %s", reply)
}
if err := tpRPC.Call(utils.APIerSv2ExecuteAction, utils.AttrExecuteAction{
Tenant: "cgrates.org",
Account: "1015",
ActionsId: "PAYMENT_2056bd2fe137082970f97102b64e42fd",
}, &reply); err != nil {
t.Error("Got error on APIerSv2.ExecuteAction: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling ExecuteAction got reply: %s", reply)
}
if err := tpRPC.Call(utils.APIerSv2ExecuteAction, utils.AttrExecuteAction{
Tenant: "cgrates.org",
Account: "1015",
ActionsId: "PAYMENT_2056bd2fe137082970f97102b64e42fd",
}, &reply); err != nil {
t.Error("Got error on APIerSv2.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(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
}
if len(acnt.BalanceMap) != 1 ||
len(acnt.BalanceMap[utils.MetaMonetary]) != 1 ||
acnt.BalanceMap[utils.MetaMonetary].GetTotalValue() != 21 {
t.Error("error matching previous created balance: ", utils.ToIJSON(acnt.BalanceMap))
}
}
// func testTpCreateExecuteActionMatch(t *testing.T) {
// var reply string
// if err := tpRPC.Call(utils.APIerSv2SetActions, &utils.AttrSetActions{
// ActionsId: "PAYMENT_2056bd2fe137082970f97102b64e42fd",
// Actions: []*utils.TPAction{
// {
// BalanceType: "*monetary",
// Identifier: "*topup",
// RatingSubject: "",
// Units: "10.500000",
// Weight: 10,
// },
// },
// }, &reply); err != nil {
// t.Error("Got error on APIerSv2.SetActions: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.SetActions got reply: %s", reply)
// }
// if err := tpRPC.Call(utils.APIerSv2ExecuteAction, utils.AttrExecuteAction{
// Tenant: "cgrates.org",
// Account: "1015",
// ActionsId: "PAYMENT_2056bd2fe137082970f97102b64e42fd",
// }, &reply); err != nil {
// t.Error("Got error on APIerSv2.ExecuteAction: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling ExecuteAction got reply: %s", reply)
// }
// if err := tpRPC.Call(utils.APIerSv2ExecuteAction, utils.AttrExecuteAction{
// Tenant: "cgrates.org",
// Account: "1015",
// ActionsId: "PAYMENT_2056bd2fe137082970f97102b64e42fd",
// }, &reply); err != nil {
// t.Error("Got error on APIerSv2.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(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
// }
// if len(acnt.BalanceMap) != 1 ||
// len(acnt.BalanceMap[utils.MetaMonetary]) != 1 ||
// acnt.BalanceMap[utils.MetaMonetary].GetTotalValue() != 21 {
// t.Error("error matching previous created balance: ", utils.ToIJSON(acnt.BalanceMap))
// }
// }
func testTpSetRemoveActions(t *testing.T) {
var reply string
if err := tpRPC.Call(utils.APIerSv2SetActions, &utils.AttrSetActions{
ActionsId: "TO_BE_DELETED",
Actions: []*utils.TPAction{
{
BalanceType: "*monetary",
Identifier: "*topup",
RatingSubject: "",
Units: "10.500000",
Weight: 10,
},
},
}, &reply); err != nil {
t.Error("Got error on APIerSv2.SetActions: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.SetActions got reply: %s", reply)
}
actionsMap := make(map[string]engine.Actions)
if err := tpRPC.Call(utils.APIerSv2GetActions, &v2.AttrGetActions{
ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"},
}, &actionsMap); err != nil {
t.Error("Got error on APIerSv2.GetActions: ", err.Error())
} else if len(actionsMap) != 1 {
t.Errorf("Calling APIerSv2.GetActions got reply: %s", utils.ToIJSON(actionsMap))
}
if err := tpRPC.Call(utils.APIerSv2RemoveActions, v1.AttrRemoveActions{
ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"},
}, &reply); err != nil {
t.Error("Got error on APIerSv2.RemoveActions: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.RemoveActions got reply: %s", reply)
}
if err := tpRPC.Call(utils.APIerSv2GetActions, &v2.AttrGetActions{
ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"},
}, &actionsMap); err == nil {
t.Error("no error on APIerSv2.GetActions: ", err)
}
}
// func testTpSetRemoveActions(t *testing.T) {
// var reply string
// if err := tpRPC.Call(utils.APIerSv2SetActions, &utils.AttrSetActions{
// ActionsId: "TO_BE_DELETED",
// Actions: []*utils.TPAction{
// {
// BalanceType: "*monetary",
// Identifier: "*topup",
// RatingSubject: "",
// Units: "10.500000",
// Weight: 10,
// },
// },
// }, &reply); err != nil {
// t.Error("Got error on APIerSv2.SetActions: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.SetActions got reply: %s", reply)
// }
// actionsMap := make(map[string]engine.Actions)
// if err := tpRPC.Call(utils.APIerSv2GetActions, &v2.AttrGetActions{
// ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"},
// }, &actionsMap); err != nil {
// t.Error("Got error on APIerSv2.GetActions: ", err.Error())
// } else if len(actionsMap) != 1 {
// t.Errorf("Calling APIerSv2.GetActions got reply: %s", utils.ToIJSON(actionsMap))
// }
// if err := tpRPC.Call(utils.APIerSv2RemoveActions, v1.AttrRemoveActions{
// ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"},
// }, &reply); err != nil {
// t.Error("Got error on APIerSv2.RemoveActions: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.RemoveActions got reply: %s", reply)
// }
// if err := tpRPC.Call(utils.APIerSv2GetActions, &v2.AttrGetActions{
// ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"},
// }, &actionsMap); err == nil {
// t.Error("no error on APIerSv2.GetActions: ", err)
// }
// }
func testTpRemoveActionsRefenced(t *testing.T) {
actionsMap := make(map[string]engine.Actions)
if err := tpRPC.Call(utils.APIerSv2GetActions, &v2.AttrGetActions{
ActionIDs: []string{"TOPUP_VOICE"},
}, &actionsMap); err != nil {
t.Error("Got error on APIerSv2.GetActions: ", err.Error())
} else if len(actionsMap) != 1 {
t.Errorf("Calling APIerSv2.GetActions got reply: %s", utils.ToIJSON(actionsMap))
}
var reply string
if err := tpRPC.Call(utils.APIerSv2RemoveActions, v1.AttrRemoveActions{
ActionIDs: []string{"TOPUP_VOICE"},
}, &reply); err != nil {
t.Error("Error on APIerSv2.RemoveActions: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.RemoveActions got reply: %s", reply)
}
/*
if err := tpRPC.Call(utils.APIerSv2GetActions, v2.AttrGetActions{
ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"},
}, &actionsMap); err == nil {
t.Error("no error on APIerSv2.GetActions: ", err)
}
*/
}
// func testTpRemoveActionsRefenced(t *testing.T) {
// actionsMap := make(map[string]engine.Actions)
// if err := tpRPC.Call(utils.APIerSv2GetActions, &v2.AttrGetActions{
// ActionIDs: []string{"TOPUP_VOICE"},
// }, &actionsMap); err != nil {
// t.Error("Got error on APIerSv2.GetActions: ", err.Error())
// } else if len(actionsMap) != 1 {
// t.Errorf("Calling APIerSv2.GetActions got reply: %s", utils.ToIJSON(actionsMap))
// }
// var reply string
// if err := tpRPC.Call(utils.APIerSv2RemoveActions, v1.AttrRemoveActions{
// ActionIDs: []string{"TOPUP_VOICE"},
// }, &reply); err != nil {
// t.Error("Error on APIerSv2.RemoveActions: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.RemoveActions got reply: %s", reply)
// }
// /*
// if err := tpRPC.Call(utils.APIerSv2GetActions, v2.AttrGetActions{
// ActionIDs: []string{"PAYMENT_2056bd2fe137082970f97102b64e42fd"},
// }, &actionsMap); err == nil {
// t.Error("no error on APIerSv2.GetActions: ", err)
// }
// */
// }
func testTpApierResetAccountActionTriggers(t *testing.T) {
var acnt engine.Account
attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1005"}
if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error(err)
} else if acnt.ActionTriggers[0].Executed != true {
t.Skip("Skipping test since Executed is not yet true")
}
var reply string
if err := tpRPC.Call(utils.APIerSv2ResetAccountActionTriggers, v1.AttrResetAccountActionTriggers{
Tenant: "cgrates.org",
Account: "1005",
GroupID: "STANDARD_TRIGGERS",
Executed: true,
}, &reply); err != nil {
t.Error("Error on APIerSv2.ResetAccountActionTriggers: ", err.Error())
} else if reply != utils.OK {
t.Errorf("Calling APIerSv2.ResetAccountActionTriggers got reply: %s", reply)
}
if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
t.Error(err)
} else if acnt.ActionTriggers[0].Executed == false {
t.Errorf("wrong action trigger executed flag: %s", utils.ToIJSON(acnt.ActionTriggers))
}
}
// func testTpApierResetAccountActionTriggers(t *testing.T) {
// var acnt engine.Account
// attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1005"}
// if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error(err)
// } else if acnt.ActionTriggers[0].Executed != true {
// t.Skip("Skipping test since Executed is not yet true")
// }
// var reply string
// if err := tpRPC.Call(utils.APIerSv2ResetAccountActionTriggers, v1.AttrResetAccountActionTriggers{
// Tenant: "cgrates.org",
// Account: "1005",
// GroupID: "STANDARD_TRIGGERS",
// Executed: true,
// }, &reply); err != nil {
// t.Error("Error on APIerSv2.ResetAccountActionTriggers: ", err.Error())
// } else if reply != utils.OK {
// t.Errorf("Calling APIerSv2.ResetAccountActionTriggers got reply: %s", reply)
// }
// if err := tpRPC.Call(utils.APIerSv2GetAccount, attrs, &acnt); err != nil {
// t.Error(err)
// } else if acnt.ActionTriggers[0].Executed == false {
// t.Errorf("wrong action trigger executed flag: %s", utils.ToIJSON(acnt.ActionTriggers))
// }
// }
func testTpStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testTpStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

294
general_tests/tut_smgeneric_it_test.go
View File

@@ -21,162 +21,162 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"reflect"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "reflect"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/ltcache"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// "github.com/cgrates/ltcache"
// )
var (
tutSMGCfgPath string
tutSMGCfgDIR string
tutSMGCfg *config.CGRConfig
tutSMGRpc *rpc.Client
smgLoadInst utils.LoadInstance // Share load information between tests
// var (
// tutSMGCfgPath string
// tutSMGCfgDIR string
// tutSMGCfg *config.CGRConfig
// tutSMGRpc *rpc.Client
// smgLoadInst utils.LoadInstance // Share load information between tests
sTestTutSMG = []func(t *testing.T){
testTutSMGInitCfg,
testTutSMGResetDataDb,
testTutSMGResetStorDb,
testTutSMGStartEngine,
testTutSMGRpcConn,
testTutSMGLoadTariffPlanFromFolder,
testTutSMGCacheStats,
testTutSMGStopCgrEngine,
}
)
// sTestTutSMG = []func(t *testing.T){
// testTutSMGInitCfg,
// testTutSMGResetDataDb,
// testTutSMGResetStorDb,
// testTutSMGStartEngine,
// testTutSMGRpcConn,
// testTutSMGLoadTariffPlanFromFolder,
// testTutSMGCacheStats,
// testTutSMGStopCgrEngine,
// }
// )
func TestTutSMG(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
t.SkipNow()
case utils.MetaMySQL:
tutSMGCfgDIR = "sessions_mysql"
case utils.MetaMongo:
t.SkipNow()
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
//mongo and sql tutmongo tutmysql
for _, stest := range sTestTutSMG {
t.Run(tutSMGCfgDIR, stest)
}
}
// func TestTutSMG(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// t.SkipNow()
// case utils.MetaMySQL:
// tutSMGCfgDIR = "sessions_mysql"
// case utils.MetaMongo:
// t.SkipNow()
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// //mongo and sql tutmongo tutmysql
// for _, stest := range sTestTutSMG {
// t.Run(tutSMGCfgDIR, stest)
// }
// }
func testTutSMGInitCfg(t *testing.T) {
tutSMGCfgPath = path.Join(*dataDir, "conf", "samples", tutSMGCfgDIR)
// Init config first
var err error
tutSMGCfg, err = config.NewCGRConfigFromPath(tutSMGCfgPath)
if err != nil {
t.Error(err)
}
}
// func testTutSMGInitCfg(t *testing.T) {
// tutSMGCfgPath = path.Join(*dataDir, "conf", "samples", tutSMGCfgDIR)
// // Init config first
// var err error
// tutSMGCfg, err = config.NewCGRConfigFromPath(tutSMGCfgPath)
// if err != nil {
// t.Error(err)
// }
// }
// Remove data in both rating and accounting db
func testTutSMGResetDataDb(t *testing.T) {
if err := engine.InitDataDB(tutSMGCfg); err != nil {
t.Fatal(err)
}
}
// // Remove data in both rating and accounting db
// func testTutSMGResetDataDb(t *testing.T) {
// if err := engine.InitDataDB(tutSMGCfg); err != nil {
// t.Fatal(err)
// }
// }
// Wipe out the cdr database
func testTutSMGResetStorDb(t *testing.T) {
if err := engine.InitStorDB(tutSMGCfg); err != nil {
t.Fatal(err)
}
}
// // Wipe out the cdr database
// func testTutSMGResetStorDb(t *testing.T) {
// if err := engine.InitStorDB(tutSMGCfg); err != nil {
// t.Fatal(err)
// }
// }
// Start CGR Engine
func testTutSMGStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(tutSMGCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// // Start CGR Engine
// func testTutSMGStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(tutSMGCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
// Connect rpc client to rater
func testTutSMGRpcConn(t *testing.T) {
var err error
tutSMGRpc, err = newRPCClient(tutSMGCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal(err)
}
}
// // Connect rpc client to rater
// func testTutSMGRpcConn(t *testing.T) {
// var err error
// tutSMGRpc, err = newRPCClient(tutSMGCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal(err)
// }
// }
// Load the tariff plan, creating accounts and their balances
func testTutSMGLoadTariffPlanFromFolder(t *testing.T) {
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")}
if err := tutSMGRpc.Call(utils.APIerSv2LoadTariffPlanFromFolder, attrs, &smgLoadInst); err != nil {
t.Error(err)
}
time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups
}
// // Load the tariff plan, creating accounts and their balances
// func testTutSMGLoadTariffPlanFromFolder(t *testing.T) {
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")}
// if err := tutSMGRpc.Call(utils.APIerSv2LoadTariffPlanFromFolder, attrs, &smgLoadInst); err != nil {
// t.Error(err)
// }
// time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups
// }
// Check loaded stats
func testTutSMGCacheStats(t *testing.T) {
var reply string
if err := tutSMGRpc.Call(utils.CacheSv1LoadCache, utils.NewAttrReloadCacheWithOpts(), &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error(reply)
}
// expectedStats := &utils.CacheStats{Destinations: 5, ReverseDestinations: 7, RatingPlans: 4, RatingProfiles: 5,
// Actions: 9, ActionPlans: 4, AccountActionPlans: 5, SharedGroups: 1, ResourceProfiles: 3,
// Resources: 3, StatQueues: 1, StatQueueProfiles: 1, Thresholds: 7, ThresholdProfiles: 7, Filters: 15,
// SupplierProfiles: 3, AttributeProfiles: 2}
var rcvStats map[string]*ltcache.CacheStats
expectedStats := engine.GetDefaultEmptyCacheStats()
expectedStats[utils.CacheRatingPlans].Items = 4
expectedStats[utils.CacheRatingProfiles].Items = 5
expectedStats[utils.CacheActions].Items = 9
expectedStats[utils.CacheActionPlans].Items = 4
expectedStats[utils.CacheSharedGroups].Items = 1
expectedStats[utils.CacheResourceProfiles].Items = 3
expectedStats[utils.CacheResources].Items = 3
expectedStats[utils.CacheStatQueues].Items = 1
expectedStats[utils.CacheStatQueueProfiles].Items = 1
expectedStats[utils.CacheThresholds].Items = 7
expectedStats[utils.CacheThresholdProfiles].Items = 7
expectedStats[utils.CacheFilters].Items = 15
expectedStats[utils.CacheRouteProfiles].Items = 3
expectedStats[utils.CacheAttributeProfiles].Items = 2
expectedStats[utils.MetaDefault].Items = 1
expectedStats[utils.CacheActionTriggers].Items = 1
expectedStats[utils.CacheLoadIDs].Items = 33
expectedStats[utils.CacheChargerProfiles].Items = 1
expectedStats[utils.CacheRPCConnections].Items = 2
expectedStats[utils.CacheThresholdFilterIndexes].Items = 10
expectedStats[utils.CacheThresholdFilterIndexes].Groups = 1
expectedStats[utils.CacheStatFilterIndexes].Items = 2
expectedStats[utils.CacheStatFilterIndexes].Groups = 1
expectedStats[utils.CacheRouteFilterIndexes].Items = 6
expectedStats[utils.CacheRouteFilterIndexes].Groups = 1
expectedStats[utils.CacheResourceFilterIndexes].Items = 6
expectedStats[utils.CacheResourceFilterIndexes].Groups = 1
expectedStats[utils.CacheChargerFilterIndexes].Items = 1
expectedStats[utils.CacheChargerFilterIndexes].Groups = 1
expectedStats[utils.CacheAttributeFilterIndexes].Items = 3
expectedStats[utils.CacheAttributeFilterIndexes].Groups = 2
expectedStats[utils.CacheReverseFilterIndexes].Items = 15
expectedStats[utils.CacheReverseFilterIndexes].Groups = 13
if err := tutSMGRpc.Call(utils.CacheSv1GetCacheStats, new(utils.AttrCacheIDsWithAPIOpts), &rcvStats); err != nil {
t.Error("Got error on CacheSv1.GetCacheStats: ", err.Error())
} else if !reflect.DeepEqual(expectedStats, rcvStats) {
t.Errorf("Calling APIerSv2.CacheSv1 expected: %+v,\n received: %+v", utils.ToJSON(expectedStats), utils.ToJSON(rcvStats))
}
}
// // Check loaded stats
// func testTutSMGCacheStats(t *testing.T) {
// var reply string
// if err := tutSMGRpc.Call(utils.CacheSv1LoadCache, utils.NewAttrReloadCacheWithOpts(), &reply); err != nil {
// t.Error(err)
// } else if reply != utils.OK {
// t.Error(reply)
// }
// // expectedStats := &utils.CacheStats{Destinations: 5, ReverseDestinations: 7, RatingPlans: 4, RatingProfiles: 5,
// // Actions: 9, ActionPlans: 4, AccountActionPlans: 5, SharedGroups: 1, ResourceProfiles: 3,
// // Resources: 3, StatQueues: 1, StatQueueProfiles: 1, Thresholds: 7, ThresholdProfiles: 7, Filters: 15,
// // SupplierProfiles: 3, AttributeProfiles: 2}
// var rcvStats map[string]*ltcache.CacheStats
// expectedStats := engine.GetDefaultEmptyCacheStats()
// expectedStats[utils.CacheRatingPlans].Items = 4
// expectedStats[utils.CacheRatingProfiles].Items = 5
// expectedStats[utils.CacheActions].Items = 9
// expectedStats[utils.CacheActionPlans].Items = 4
// expectedStats[utils.CacheSharedGroups].Items = 1
// expectedStats[utils.CacheResourceProfiles].Items = 3
// expectedStats[utils.CacheResources].Items = 3
// expectedStats[utils.CacheStatQueues].Items = 1
// expectedStats[utils.CacheStatQueueProfiles].Items = 1
// expectedStats[utils.CacheThresholds].Items = 7
// expectedStats[utils.CacheThresholdProfiles].Items = 7
// expectedStats[utils.CacheFilters].Items = 15
// expectedStats[utils.CacheRouteProfiles].Items = 3
// expectedStats[utils.CacheAttributeProfiles].Items = 2
// expectedStats[utils.MetaDefault].Items = 1
// expectedStats[utils.CacheActionTriggers].Items = 1
// expectedStats[utils.CacheLoadIDs].Items = 33
// expectedStats[utils.CacheChargerProfiles].Items = 1
// expectedStats[utils.CacheRPCConnections].Items = 2
// expectedStats[utils.CacheThresholdFilterIndexes].Items = 10
// expectedStats[utils.CacheThresholdFilterIndexes].Groups = 1
// expectedStats[utils.CacheStatFilterIndexes].Items = 2
// expectedStats[utils.CacheStatFilterIndexes].Groups = 1
// expectedStats[utils.CacheRouteFilterIndexes].Items = 6
// expectedStats[utils.CacheRouteFilterIndexes].Groups = 1
// expectedStats[utils.CacheResourceFilterIndexes].Items = 6
// expectedStats[utils.CacheResourceFilterIndexes].Groups = 1
// expectedStats[utils.CacheChargerFilterIndexes].Items = 1
// expectedStats[utils.CacheChargerFilterIndexes].Groups = 1
// expectedStats[utils.CacheAttributeFilterIndexes].Items = 3
// expectedStats[utils.CacheAttributeFilterIndexes].Groups = 2
// expectedStats[utils.CacheReverseFilterIndexes].Items = 15
// expectedStats[utils.CacheReverseFilterIndexes].Groups = 13
// if err := tutSMGRpc.Call(utils.CacheSv1GetCacheStats, new(utils.AttrCacheIDsWithAPIOpts), &rcvStats); err != nil {
// t.Error("Got error on CacheSv1.GetCacheStats: ", err.Error())
// } else if !reflect.DeepEqual(expectedStats, rcvStats) {
// t.Errorf("Calling APIerSv2.CacheSv1 expected: %+v,\n received: %+v", utils.ToJSON(expectedStats), utils.ToJSON(rcvStats))
// }
// }
func testTutSMGStopCgrEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
t.Error(err)
}
}
// func testTutSMGStopCgrEngine(t *testing.T) {
// if err := engine.KillEngine(100); err != nil {
// t.Error(err)
// }
// }

682
general_tests/tutorial2_it_test.go
View File

@@ -21,358 +21,358 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
tutCfgPath string
tutCfg *config.CGRConfig
tutRpc *rpc.Client
tutCfgDir string //run tests for specific configuration
tutDelay int
)
// var (
// tutCfgPath string
// tutCfg *config.CGRConfig
// tutRpc *rpc.Client
// tutCfgDir string //run tests for specific configuration
// tutDelay int
// )
var sTutTests = []func(t *testing.T){
testTutLoadConfig,
testTutResetDB,
testTutStartEngine,
testTutRpcConn,
testTutFromFolder,
testTutGetCost,
testTutAccounts,
testTutStopEngine,
}
// var sTutTests = []func(t *testing.T){
// testTutLoadConfig,
// testTutResetDB,
// testTutStartEngine,
// testTutRpcConn,
// testTutFromFolder,
// testTutGetCost,
// testTutAccounts,
// testTutStopEngine,
// }
//Test start here
func TestTutorial2(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
tutCfgDir = "tutinternal"
case utils.MetaMySQL:
tutCfgDir = "tutmysql2"
case utils.MetaMongo:
tutCfgDir = "tutmongo2"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
if *encoding == utils.MetaGOB {
tutCfgDir += "_gob"
}
// //Test start here
// func TestTutorial2(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// tutCfgDir = "tutinternal"
// case utils.MetaMySQL:
// tutCfgDir = "tutmysql2"
// case utils.MetaMongo:
// tutCfgDir = "tutmongo2"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// if *encoding == utils.MetaGOB {
// tutCfgDir += "_gob"
// }
for _, stest := range sTutTests {
t.Run(tutCfgDir, stest)
}
}
// for _, stest := range sTutTests {
// t.Run(tutCfgDir, stest)
// }
// }
func testTutLoadConfig(t *testing.T) {
var err error
tutCfgPath = path.Join(*dataDir, "conf", "samples", tutCfgDir)
if tutCfg, err = config.NewCGRConfigFromPath(tutCfgPath); err != nil {
t.Error(err)
}
tutDelay = 2000
}
// func testTutLoadConfig(t *testing.T) {
// var err error
// tutCfgPath = path.Join(*dataDir, "conf", "samples", tutCfgDir)
// if tutCfg, err = config.NewCGRConfigFromPath(tutCfgPath); err != nil {
// t.Error(err)
// }
// tutDelay = 2000
// }
func testTutResetDB(t *testing.T) {
if err := engine.InitDataDB(tutCfg); err != nil {
t.Fatal(err)
}
if err := engine.InitStorDB(tutCfg); err != nil {
t.Fatal(err)
}
}
// func testTutResetDB(t *testing.T) {
// if err := engine.InitDataDB(tutCfg); err != nil {
// t.Fatal(err)
// }
// if err := engine.InitStorDB(tutCfg); err != nil {
// t.Fatal(err)
// }
// }
func testTutStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(tutCfgPath, tutDelay); err != nil {
t.Fatal(err)
}
}
// func testTutStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(tutCfgPath, tutDelay); err != nil {
// t.Fatal(err)
// }
// }
func testTutStopEngine(t *testing.T) {
if err := engine.KillEngine(tutDelay); err != nil {
t.Error(err)
}
}
// func testTutStopEngine(t *testing.T) {
// if err := engine.KillEngine(tutDelay); err != nil {
// t.Error(err)
// }
// }
func testTutRpcConn(t *testing.T) {
var err error
if tutRpc, err = newRPCClient(tutCfg.ListenCfg()); err != nil {
t.Fatal("could not connect to rater: ", err.Error())
}
}
// func testTutRpcConn(t *testing.T) {
// var err error
// if tutRpc, err = newRPCClient(tutCfg.ListenCfg()); err != nil {
// t.Fatal("could not connect to rater: ", err.Error())
// }
// }
func testTutFromFolder(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{
FolderPath: path.Join(*dataDir, "tariffplans", "tutorial2")}
if err := tutRpc.Call(utils.APIerSv1LoadTariffPlanFromFolder,
attrs, &reply); err != nil {
t.Error(err)
}
time.Sleep(100 * time.Millisecond)
}
// func testTutFromFolder(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{
// FolderPath: path.Join(*dataDir, "tariffplans", "tutorial2")}
// if err := tutRpc.Call(utils.APIerSv1LoadTariffPlanFromFolder,
// attrs, &reply); err != nil {
// t.Error(err)
// }
// time.Sleep(100 * time.Millisecond)
// }
func testTutGetCost(t *testing.T) {
// Standard pricing for 1001->1002
attrs := v1.AttrGetCost{
Subject: "1001",
Destination: "1002",
AnswerTime: "*now",
Usage: "45s",
}
var rply *engine.EventCost
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 0.550000 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
// Fallback pricing from *any, Usage will be rounded to 60s
attrs = v1.AttrGetCost{
Subject: "1001",
Destination: "1003",
AnswerTime: "2019-03-11T09:00:00Z",
Usage: "45s",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 1.4 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
// Fallback pricing from *any, Usage will be rounded to 60s
attrs = v1.AttrGetCost{
Subject: "1001",
Destination: "1003",
AnswerTime: "2019-03-11T21:00:00Z",
Usage: "45s",
}
// *any to 2001
attrs = v1.AttrGetCost{
Subject: "1002",
Destination: "2001",
AnswerTime: "*now",
Usage: "45s",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 1.4 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
// *any to 2001 on NEW_YEAR
attrs = v1.AttrGetCost{
Subject: "1002",
Destination: "2001",
AnswerTime: "2020-01-01T21:00:00Z",
Usage: "45s",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 0.55 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
// Fallback pricing from *any, Usage will be rounded to 60s
attrs = v1.AttrGetCost{
Subject: "1001",
Destination: "1003",
AnswerTime: "2019-03-11T21:00:00Z",
Usage: "45s",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 0.55 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
// Unauthorized destination
attrs = v1.AttrGetCost{
Subject: "1001",
Destination: "4003",
AnswerTime: "2019-03-11T09:00:00Z",
Usage: "1m",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err == nil ||
err.Error() != "SERVER_ERROR: UNAUTHORIZED_DESTINATION" {
t.Error("Unexpected nil error received: ", err)
}
// Data charging
attrs = v1.AttrGetCost{
Category: "data",
Subject: "1001",
AnswerTime: "*now",
Usage: "2048",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 2.0 { // FixMe: missing ConnectFee out of Cost
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
// SMS charging 1002
attrs = v1.AttrGetCost{
Category: "sms",
Subject: "1003",
Destination: "1002",
AnswerTime: "*now",
Usage: "1",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 0.1 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
// SMS charging 10
attrs = v1.AttrGetCost{
Category: "sms",
Subject: "1001",
Destination: "1003",
AnswerTime: "*now",
Usage: "1",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 0.2 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
// SMS charging UNAUTHORIZED
attrs = v1.AttrGetCost{
Category: "sms",
Subject: "1001",
Destination: "2001",
AnswerTime: "*now",
Usage: "1",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err == nil ||
err.Error() != "SERVER_ERROR: UNAUTHORIZED_DESTINATION" {
t.Error("Unexpected nil error received: ", err)
}
// Per call charges
attrs = v1.AttrGetCost{
Category: "call",
Subject: "RPF_SPECIAL_BLC",
Destination: "1002",
AnswerTime: "*now",
Usage: "5m",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 0.1 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
// reseller1 pricing for 1001->1002
attrs = v1.AttrGetCost{
Subject: "1001",
Destination: "1002",
AnswerTime: "*now",
Usage: "45s",
Category: "reseller1",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 0.1 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
// reseller1 pricing for 1001->1002 duration independent
attrs = v1.AttrGetCost{
Subject: "1001",
Destination: "1002",
AnswerTime: "*now",
Usage: "10m45s",
Category: "reseller1",
}
if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 0.1 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
}
// func testTutGetCost(t *testing.T) {
// // Standard pricing for 1001->1002
// attrs := v1.AttrGetCost{
// Subject: "1001",
// Destination: "1002",
// AnswerTime: "*now",
// Usage: "45s",
// }
// var rply *engine.EventCost
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 0.550000 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// // Fallback pricing from *any, Usage will be rounded to 60s
// attrs = v1.AttrGetCost{
// Subject: "1001",
// Destination: "1003",
// AnswerTime: "2019-03-11T09:00:00Z",
// Usage: "45s",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 1.4 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// // Fallback pricing from *any, Usage will be rounded to 60s
// attrs = v1.AttrGetCost{
// Subject: "1001",
// Destination: "1003",
// AnswerTime: "2019-03-11T21:00:00Z",
// Usage: "45s",
// }
// // *any to 2001
// attrs = v1.AttrGetCost{
// Subject: "1002",
// Destination: "2001",
// AnswerTime: "*now",
// Usage: "45s",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 1.4 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// // *any to 2001 on NEW_YEAR
// attrs = v1.AttrGetCost{
// Subject: "1002",
// Destination: "2001",
// AnswerTime: "2020-01-01T21:00:00Z",
// Usage: "45s",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 0.55 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// // Fallback pricing from *any, Usage will be rounded to 60s
// attrs = v1.AttrGetCost{
// Subject: "1001",
// Destination: "1003",
// AnswerTime: "2019-03-11T21:00:00Z",
// Usage: "45s",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 0.55 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// // Unauthorized destination
// attrs = v1.AttrGetCost{
// Subject: "1001",
// Destination: "4003",
// AnswerTime: "2019-03-11T09:00:00Z",
// Usage: "1m",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err == nil ||
// err.Error() != "SERVER_ERROR: UNAUTHORIZED_DESTINATION" {
// t.Error("Unexpected nil error received: ", err)
// }
// // Data charging
// attrs = v1.AttrGetCost{
// Category: "data",
// Subject: "1001",
// AnswerTime: "*now",
// Usage: "2048",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 2.0 { // FixMe: missing ConnectFee out of Cost
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// // SMS charging 1002
// attrs = v1.AttrGetCost{
// Category: "sms",
// Subject: "1003",
// Destination: "1002",
// AnswerTime: "*now",
// Usage: "1",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 0.1 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// // SMS charging 10
// attrs = v1.AttrGetCost{
// Category: "sms",
// Subject: "1001",
// Destination: "1003",
// AnswerTime: "*now",
// Usage: "1",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 0.2 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// // SMS charging UNAUTHORIZED
// attrs = v1.AttrGetCost{
// Category: "sms",
// Subject: "1001",
// Destination: "2001",
// AnswerTime: "*now",
// Usage: "1",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err == nil ||
// err.Error() != "SERVER_ERROR: UNAUTHORIZED_DESTINATION" {
// t.Error("Unexpected nil error received: ", err)
// }
// // Per call charges
// attrs = v1.AttrGetCost{
// Category: "call",
// Subject: "RPF_SPECIAL_BLC",
// Destination: "1002",
// AnswerTime: "*now",
// Usage: "5m",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 0.1 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// // reseller1 pricing for 1001->1002
// attrs = v1.AttrGetCost{
// Subject: "1001",
// Destination: "1002",
// AnswerTime: "*now",
// Usage: "45s",
// Category: "reseller1",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 0.1 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// // reseller1 pricing for 1001->1002 duration independent
// attrs = v1.AttrGetCost{
// Subject: "1001",
// Destination: "1002",
// AnswerTime: "*now",
// Usage: "10m45s",
// Category: "reseller1",
// }
// if err := tutRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 0.1 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// }
func testTutAccounts(t *testing.T) {
// make sure Account was created
var acnt *engine.Account
if err := tutRpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"},
&acnt); err != nil {
t.Fatal(err)
}
if len(acnt.BalanceMap) != 4 ||
len(acnt.BalanceMap[utils.MetaMonetary]) != 1 ||
acnt.BalanceMap[utils.MetaMonetary][0].Value != 10 ||
len(acnt.BalanceMap[utils.MetaVoice]) != 2 ||
len(acnt.BalanceMap[utils.MetaSMS]) != 1 ||
acnt.BalanceMap[utils.MetaSMS][0].Value != 100 ||
len(acnt.BalanceMap[utils.MetaData]) != 1 ||
acnt.BalanceMap[utils.MetaData][0].Value != 1024 ||
len(acnt.ActionTriggers) != 2 ||
acnt.Disabled {
t.Errorf("received account: %s", utils.ToIJSON(acnt))
}
// func testTutAccounts(t *testing.T) {
// // make sure Account was created
// var acnt *engine.Account
// if err := tutRpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"},
// &acnt); err != nil {
// t.Fatal(err)
// }
// if len(acnt.BalanceMap) != 4 ||
// len(acnt.BalanceMap[utils.MetaMonetary]) != 1 ||
// acnt.BalanceMap[utils.MetaMonetary][0].Value != 10 ||
// len(acnt.BalanceMap[utils.MetaVoice]) != 2 ||
// len(acnt.BalanceMap[utils.MetaSMS]) != 1 ||
// acnt.BalanceMap[utils.MetaSMS][0].Value != 100 ||
// len(acnt.BalanceMap[utils.MetaData]) != 1 ||
// acnt.BalanceMap[utils.MetaData][0].Value != 1024 ||
// len(acnt.ActionTriggers) != 2 ||
// acnt.Disabled {
// t.Errorf("received account: %s", utils.ToIJSON(acnt))
// }
// test ActionTriggers
attrBlc := utils.AttrSetBalance{
Tenant: "cgrates.org",
Account: "1001",
BalanceType: utils.MetaMonetary,
Value: 1,
Balance: map[string]interface{}{
utils.ID: utils.MetaDefault,
},
}
var rplySetBlc string
if err := tutRpc.Call(utils.APIerSv1SetBalance, attrBlc, &rplySetBlc); err != nil {
t.Error("Got error on APIerSv1.SetBalance: ", err.Error())
}
if err := tutRpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"},
&acnt); err != nil {
t.Error(err)
} else if len(acnt.BalanceMap[utils.MetaSMS]) != 2 ||
acnt.GetBalanceWithID(utils.MetaSMS, "BONUS_SMSes").Value != 10 {
t.Errorf("account: %s", utils.ToIJSON(acnt))
}
attrBlc = utils.AttrSetBalance{
Tenant: "cgrates.org",
Account: "1001",
BalanceType: utils.MetaMonetary,
Value: 101,
Balance: map[string]interface{}{
utils.ID: utils.MetaDefault,
},
}
if err := tutRpc.Call(utils.APIerSv1SetBalance, attrBlc, &rplySetBlc); err != nil {
t.Error("Got error on APIerSv1.SetBalance: ", err.Error())
}
if err := tutRpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"},
&acnt); err != nil {
t.Error(err)
} else if !acnt.Disabled {
t.Errorf("account: %s", utils.ToIJSON(acnt))
}
// enable the account again
var rplySetAcnt string
if err := tutRpc.Call(utils.APIerSv2SetAccount,
&v2.AttrSetAccount{
Tenant: "cgrates.org",
Account: "1001",
ExtraOptions: map[string]bool{
utils.Disabled: false,
},
}, &rplySetAcnt); err != nil {
t.Error(err)
}
acnt = new(engine.Account)
if err := tutRpc.Call(utils.APIerSv2GetAccount,
&utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"},
&acnt); err != nil {
t.Error(err)
} else if acnt.Disabled {
t.Errorf("account: %s", utils.ToJSON(acnt))
}
}
// // test ActionTriggers
// attrBlc := utils.AttrSetBalance{
// Tenant: "cgrates.org",
// Account: "1001",
// BalanceType: utils.MetaMonetary,
// Value: 1,
// Balance: map[string]interface{}{
// utils.ID: utils.MetaDefault,
// },
// }
// var rplySetBlc string
// if err := tutRpc.Call(utils.APIerSv1SetBalance, attrBlc, &rplySetBlc); err != nil {
// t.Error("Got error on APIerSv1.SetBalance: ", err.Error())
// }
// if err := tutRpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"},
// &acnt); err != nil {
// t.Error(err)
// } else if len(acnt.BalanceMap[utils.MetaSMS]) != 2 ||
// acnt.GetBalanceWithID(utils.MetaSMS, "BONUS_SMSes").Value != 10 {
// t.Errorf("account: %s", utils.ToIJSON(acnt))
// }
// attrBlc = utils.AttrSetBalance{
// Tenant: "cgrates.org",
// Account: "1001",
// BalanceType: utils.MetaMonetary,
// Value: 101,
// Balance: map[string]interface{}{
// utils.ID: utils.MetaDefault,
// },
// }
// if err := tutRpc.Call(utils.APIerSv1SetBalance, attrBlc, &rplySetBlc); err != nil {
// t.Error("Got error on APIerSv1.SetBalance: ", err.Error())
// }
// if err := tutRpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"},
// &acnt); err != nil {
// t.Error(err)
// } else if !acnt.Disabled {
// t.Errorf("account: %s", utils.ToIJSON(acnt))
// }
// // enable the account again
// var rplySetAcnt string
// if err := tutRpc.Call(utils.APIerSv2SetAccount,
// &v2.AttrSetAccount{
// Tenant: "cgrates.org",
// Account: "1001",
// ExtraOptions: map[string]bool{
// utils.Disabled: false,
// },
// }, &rplySetAcnt); err != nil {
// t.Error(err)
// }
// acnt = new(engine.Account)
// if err := tutRpc.Call(utils.APIerSv2GetAccount,
// &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"},
// &acnt); err != nil {
// t.Error(err)
// } else if acnt.Disabled {
// t.Errorf("account: %s", utils.ToJSON(acnt))
// }
// }

232
general_tests/tutorial_it_test.go
View File

@@ -21,131 +21,131 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"flag"
"net/rpc"
"path"
"testing"
"time"
// import (
// "flag"
// "net/rpc"
// "path"
// "testing"
// "time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
// "github.com/cgrates/cgrates/config"
// "github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/utils"
// )
var (
itTestMongoAtalas = flag.Bool("mongo_atlas", false, "Run the test with mongo atalas connection")
tutorialCfgPath string
tutorialCfg *config.CGRConfig
tutorialRpc *rpc.Client
tutorialConfDIR string //run tests for specific configuration
tutorialDelay int
// var (
// itTestMongoAtalas = flag.Bool("mongo_atlas", false, "Run the test with mongo atalas connection")
// tutorialCfgPath string
// tutorialCfg *config.CGRConfig
// tutorialRpc *rpc.Client
// tutorialConfDIR string //run tests for specific configuration
// tutorialDelay int
sTestsTutorials = []func(t *testing.T){
testTutorialLoadConfig,
testTutorialResetDB,
testTutorialStartEngine,
testTutorialRpcConn,
testTutorialFromFolder,
testTutorialGetCost,
testTutorialStopEngine,
}
)
// sTestsTutorials = []func(t *testing.T){
// testTutorialLoadConfig,
// testTutorialResetDB,
// testTutorialStartEngine,
// testTutorialRpcConn,
// testTutorialFromFolder,
// testTutorialGetCost,
// testTutorialStopEngine,
// }
// )
//Test start here
func TestTutorialMongoAtlas(t *testing.T) {
if !*itTestMongoAtalas {
return
}
tutorialConfDIR = "mongoatlas"
for _, stest := range sTestsTutorials {
t.Run(tutorialConfDIR, stest)
}
}
// //Test start here
// func TestTutorialMongoAtlas(t *testing.T) {
// if !*itTestMongoAtalas {
// return
// }
// tutorialConfDIR = "mongoatlas"
// for _, stest := range sTestsTutorials {
// t.Run(tutorialConfDIR, stest)
// }
// }
func TestTutorial(t *testing.T) {
switch *dbType {
case utils.MetaInternal:
tutorialConfDIR = "tutinternal"
case utils.MetaMySQL:
tutorialConfDIR = "tutmysql"
case utils.MetaMongo:
tutorialConfDIR = "tutmongo"
case utils.MetaPostgres:
t.SkipNow()
default:
t.Fatal("Unknown Database type")
}
for _, stest := range sTestsTutorials {
t.Run(tutorialConfDIR, stest)
}
}
// func TestTutorial(t *testing.T) {
// switch *dbType {
// case utils.MetaInternal:
// tutorialConfDIR = "tutinternal"
// case utils.MetaMySQL:
// tutorialConfDIR = "tutmysql"
// case utils.MetaMongo:
// tutorialConfDIR = "tutmongo"
// case utils.MetaPostgres:
// t.SkipNow()
// default:
// t.Fatal("Unknown Database type")
// }
// for _, stest := range sTestsTutorials {
// t.Run(tutorialConfDIR, stest)
// }
// }
func testTutorialLoadConfig(t *testing.T) {
var err error
tutorialCfgPath = path.Join(*dataDir, "conf", "samples", tutorialConfDIR)
if tutorialCfg, err = config.NewCGRConfigFromPath(tutorialCfgPath); err != nil {
t.Error(err)
}
switch tutorialConfDIR {
case "mongoatlas": // Mongo needs more time to reset db
tutorialDelay = 4000
default:
tutorialDelay = 2000
}
}
// func testTutorialLoadConfig(t *testing.T) {
// var err error
// tutorialCfgPath = path.Join(*dataDir, "conf", "samples", tutorialConfDIR)
// if tutorialCfg, err = config.NewCGRConfigFromPath(tutorialCfgPath); err != nil {
// t.Error(err)
// }
// switch tutorialConfDIR {
// case "mongoatlas": // Mongo needs more time to reset db
// tutorialDelay = 4000
// default:
// tutorialDelay = 2000
// }
// }
func testTutorialResetDB(t *testing.T) {
if err := engine.InitDataDB(tutorialCfg); err != nil {
t.Fatal(err)
}
if err := engine.InitStorDB(tutorialCfg); err != nil {
t.Fatal(err)
}
}
// func testTutorialResetDB(t *testing.T) {
// if err := engine.InitDataDB(tutorialCfg); err != nil {
// t.Fatal(err)
// }
// if err := engine.InitStorDB(tutorialCfg); err != nil {
// t.Fatal(err)
// }
// }
func testTutorialStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(tutorialCfgPath, tutorialDelay); err != nil {
t.Fatal(err)
}
}
// func testTutorialStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(tutorialCfgPath, tutorialDelay); err != nil {
// t.Fatal(err)
// }
// }
func testTutorialRpcConn(t *testing.T) {
var err error
tutorialRpc, err = newRPCClient(tutorialCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal("Could not connect to rater: ", err.Error())
}
}
// func testTutorialRpcConn(t *testing.T) {
// var err error
// tutorialRpc, err = newRPCClient(tutorialCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed
// if err != nil {
// t.Fatal("Could not connect to rater: ", err.Error())
// }
// }
func testTutorialFromFolder(t *testing.T) {
var reply string
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")}
if err := tutorialRpc.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
t.Error(err)
}
time.Sleep(100 * time.Millisecond)
}
// func testTutorialFromFolder(t *testing.T) {
// var reply string
// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")}
// if err := tutorialRpc.Call(utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
// t.Error(err)
// }
// time.Sleep(100 * time.Millisecond)
// }
func testTutorialGetCost(t *testing.T) {
attrs := v1.AttrGetCost{
Tenant: "cgrates.org",
Category: "call",
Subject: "1001",
Destination: "1002",
AnswerTime: "*now",
Usage: "2m10s",
}
var rply *engine.EventCost
if err := tutorialRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
t.Error("Unexpected nil error received: ", err.Error())
} else if *rply.Cost != 0.716900 {
t.Errorf("Unexpected cost received: %f", *rply.Cost)
}
}
// func testTutorialGetCost(t *testing.T) {
// attrs := v1.AttrGetCost{
// Tenant: "cgrates.org",
// Category: "call",
// Subject: "1001",
// Destination: "1002",
// AnswerTime: "*now",
// Usage: "2m10s",
// }
// var rply *engine.EventCost
// if err := tutorialRpc.Call(utils.APIerSv1GetCost, &attrs, &rply); err != nil {
// t.Error("Unexpected nil error received: ", err.Error())
// } else if *rply.Cost != 0.716900 {
// t.Errorf("Unexpected cost received: %f", *rply.Cost)
// }
// }
func testTutorialStopEngine(t *testing.T) {
if err := engine.KillEngine(tutorialDelay); err != nil {
t.Error(err)
}
}
// func testTutorialStopEngine(t *testing.T) {
// if err := engine.KillEngine(tutorialDelay); err != nil {
// t.Error(err)
// }
// }

466
general_tests/twoengines_it_test.go
View File

@@ -21,253 +21,253 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package general_tests
import (
"net/rpc"
"path"
"reflect"
"testing"
"time"
// import (
// "net/rpc"
// "path"
// "reflect"
// "testing"
// "time"
"github.com/cgrates/cgrates/utils"
// "github.com/cgrates/cgrates/utils"
"github.com/cgrates/cgrates/engine"
// "github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/config"
)
// "github.com/cgrates/cgrates/config"
// )
var (
engineOneCfgPath string
engineOneCfg *config.CGRConfig
engineOneRpc *rpc.Client
// var (
// engineOneCfgPath string
// engineOneCfg *config.CGRConfig
// engineOneRpc *rpc.Client
engineTwoCfgPath string
engineTwoCfg *config.CGRConfig
engineTwoRpc *rpc.Client
)
// engineTwoCfgPath string
// engineTwoCfg *config.CGRConfig
// engineTwoRpc *rpc.Client
// )
var sTestsTwoEnginesIT = []func(t *testing.T){
testTwoEnginesInitConfig,
testTwoEnginesInitDataDB,
testTwoEnginesInitStorDB,
testTwoEnginesStartEngine,
testTwoEnginesRPC,
testTwoEnginesCheckCacheBeforeSet,
testTwoEnginesSetThreshold,
testTwoEnginesCheckCacheAfterSet,
testTwoEnginesUpdateThreshold,
testTwoEnginesKillEngines,
}
// var sTestsTwoEnginesIT = []func(t *testing.T){
// testTwoEnginesInitConfig,
// testTwoEnginesInitDataDB,
// testTwoEnginesInitStorDB,
// testTwoEnginesStartEngine,
// testTwoEnginesRPC,
// testTwoEnginesCheckCacheBeforeSet,
// testTwoEnginesSetThreshold,
// testTwoEnginesCheckCacheAfterSet,
// testTwoEnginesUpdateThreshold,
// testTwoEnginesKillEngines,
// }
func TestTwoEngines(t *testing.T) {
for _, test := range sTestsTwoEnginesIT {
t.Run("TestTwoEngines", test)
}
}
// func TestTwoEngines(t *testing.T) {
// for _, test := range sTestsTwoEnginesIT {
// t.Run("TestTwoEngines", test)
// }
// }
func testTwoEnginesInitConfig(t *testing.T) {
engineOneCfgPath = path.Join(*dataDir, "conf", "samples", "twoengines", "engine1")
if engineOneCfg, err = config.NewCGRConfigFromPath(engineOneCfgPath); err != nil {
t.Fatal(err)
}
engineTwoCfgPath = path.Join(*dataDir, "conf", "samples", "twoengines", "engine2")
if engineTwoCfg, err = config.NewCGRConfigFromPath(engineTwoCfgPath); err != nil {
t.Fatal(err)
}
// func testTwoEnginesInitConfig(t *testing.T) {
// engineOneCfgPath = path.Join(*dataDir, "conf", "samples", "twoengines", "engine1")
// if engineOneCfg, err = config.NewCGRConfigFromPath(engineOneCfgPath); err != nil {
// t.Fatal(err)
// }
// engineTwoCfgPath = path.Join(*dataDir, "conf", "samples", "twoengines", "engine2")
// if engineTwoCfg, err = config.NewCGRConfigFromPath(engineTwoCfgPath); err != nil {
// t.Fatal(err)
// }
}
func testTwoEnginesInitDataDB(t *testing.T) {
if err := engine.InitDataDB(engineOneCfg); err != nil {
t.Fatal(err)
}
}
func testTwoEnginesInitStorDB(t *testing.T) {
if err := engine.InitStorDB(engineOneCfg); err != nil {
t.Fatal(err)
}
}
func testTwoEnginesStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(engineOneCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
if _, err := engine.StartEngine(engineTwoCfgPath, *waitRater); err != nil {
t.Fatal(err)
}
}
// }
// func testTwoEnginesInitDataDB(t *testing.T) {
// if err := engine.InitDataDB(engineOneCfg); err != nil {
// t.Fatal(err)
// }
// }
// func testTwoEnginesInitStorDB(t *testing.T) {
// if err := engine.InitStorDB(engineOneCfg); err != nil {
// t.Fatal(err)
// }
// }
// func testTwoEnginesStartEngine(t *testing.T) {
// if _, err := engine.StopStartEngine(engineOneCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// if _, err := engine.StartEngine(engineTwoCfgPath, *waitRater); err != nil {
// t.Fatal(err)
// }
// }
func testTwoEnginesRPC(t *testing.T) {
var err error
engineOneRpc, err = newRPCClient(engineOneCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
engineTwoRpc, err = newRPCClient(engineTwoCfg.ListenCfg())
if err != nil {
t.Fatal(err)
}
}
// func testTwoEnginesRPC(t *testing.T) {
// var err error
// engineOneRpc, err = newRPCClient(engineOneCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// engineTwoRpc, err = newRPCClient(engineTwoCfg.ListenCfg())
// if err != nil {
// t.Fatal(err)
// }
// }
func testTwoEnginesCheckCacheBeforeSet(t *testing.T) {
var reply bool
argHasItem := utils.ArgsGetCacheItem{
CacheID: utils.CacheThresholdProfiles,
ItemID: "cgrates.org:THD_TwoEnginesTest",
}
if err := engineOneRpc.Call(utils.CacheSv1HasItem, argHasItem, &reply); err != nil {
t.Error(err)
} else if reply {
t.Errorf("Expected: false , received: %v ", reply)
}
var rcvKeys []string
argGetItemIDs := utils.ArgsGetCacheItemIDs{
CacheID: utils.CacheThresholdProfiles,
}
if err := engineOneRpc.Call(utils.CacheSv1GetItemIDs, argGetItemIDs, &rcvKeys); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Fatalf("Expected error: %s received error: %s and reply: %v ", utils.ErrNotFound, err.Error(), rcvKeys)
}
// func testTwoEnginesCheckCacheBeforeSet(t *testing.T) {
// var reply bool
// argHasItem := utils.ArgsGetCacheItem{
// CacheID: utils.CacheThresholdProfiles,
// ItemID: "cgrates.org:THD_TwoEnginesTest",
// }
// if err := engineOneRpc.Call(utils.CacheSv1HasItem, argHasItem, &reply); err != nil {
// t.Error(err)
// } else if reply {
// t.Errorf("Expected: false , received: %v ", reply)
// }
// var rcvKeys []string
// argGetItemIDs := utils.ArgsGetCacheItemIDs{
// CacheID: utils.CacheThresholdProfiles,
// }
// if err := engineOneRpc.Call(utils.CacheSv1GetItemIDs, argGetItemIDs, &rcvKeys); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Fatalf("Expected error: %s received error: %s and reply: %v ", utils.ErrNotFound, err.Error(), rcvKeys)
// }
if err := engineTwoRpc.Call(utils.CacheSv1HasItem, argHasItem, &reply); err != nil {
t.Error(err)
} else if reply {
t.Errorf("Expected: false , received: %v ", reply)
}
if err := engineTwoRpc.Call(utils.CacheSv1GetItemIDs, argGetItemIDs, &rcvKeys); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Fatalf("Expected error: %s received error: %s and reply: %v ", utils.ErrNotFound, err.Error(), rcvKeys)
}
}
// if err := engineTwoRpc.Call(utils.CacheSv1HasItem, argHasItem, &reply); err != nil {
// t.Error(err)
// } else if reply {
// t.Errorf("Expected: false , received: %v ", reply)
// }
// if err := engineTwoRpc.Call(utils.CacheSv1GetItemIDs, argGetItemIDs, &rcvKeys); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Fatalf("Expected error: %s received error: %s and reply: %v ", utils.ErrNotFound, err.Error(), rcvKeys)
// }
// }
func testTwoEnginesSetThreshold(t *testing.T) {
var reply *engine.ThresholdProfile
// enforce caching with nil on engine2 so CacheSv1.ReloadCache load correctly the threshold
if err := engineTwoRpc.Call(utils.APIerSv1GetThresholdProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "THD_TwoEnginesTest"}, &reply); err == nil ||
err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
var result string
tPrfl := &engine.ThresholdProfileWithAPIOpts{
ThresholdProfile: &engine.ThresholdProfile{
Tenant: "cgrates.org",
ID: "THD_TwoEnginesTest",
FilterIDs: []string{"*string:~*req.Account:1001"},
MaxHits: -1,
MinSleep: 5 * time.Minute,
Blocker: false,
Weight: 20.0,
ActionProfileIDs: []string{"ACT_1"},
Async: true,
},
}
if err := engineOneRpc.Call(utils.APIerSv1SetThresholdProfile, tPrfl, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
if err := engineOneRpc.Call(utils.APIerSv1GetThresholdProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "THD_TwoEnginesTest"}, &reply); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(tPrfl.ThresholdProfile, reply) {
t.Errorf("Expecting: %+v, received: %+v", tPrfl.ThresholdProfile, reply)
}
}
// func testTwoEnginesSetThreshold(t *testing.T) {
// var reply *engine.ThresholdProfile
// // enforce caching with nil on engine2 so CacheSv1.ReloadCache load correctly the threshold
// if err := engineTwoRpc.Call(utils.APIerSv1GetThresholdProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "THD_TwoEnginesTest"}, &reply); err == nil ||
// err.Error() != utils.ErrNotFound.Error() {
// t.Error(err)
// }
// var result string
// tPrfl := &engine.ThresholdProfileWithAPIOpts{
// ThresholdProfile: &engine.ThresholdProfile{
// Tenant: "cgrates.org",
// ID: "THD_TwoEnginesTest",
// FilterIDs: []string{"*string:~*req.Account:1001"},
// MaxHits: -1,
// MinSleep: 5 * time.Minute,
// Blocker: false,
// Weight: 20.0,
// ActionProfileIDs: []string{"ACT_1"},
// Async: true,
// },
// }
// if err := engineOneRpc.Call(utils.APIerSv1SetThresholdProfile, tPrfl, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
// if err := engineOneRpc.Call(utils.APIerSv1GetThresholdProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "THD_TwoEnginesTest"}, &reply); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(tPrfl.ThresholdProfile, reply) {
// t.Errorf("Expecting: %+v, received: %+v", tPrfl.ThresholdProfile, reply)
// }
// }
func testTwoEnginesCheckCacheAfterSet(t *testing.T) {
var reply bool
expected := true
argHasItem := utils.ArgsGetCacheItem{
CacheID: utils.CacheThresholdProfiles,
ItemID: "cgrates.org:THD_TwoEnginesTest",
}
if err := engineOneRpc.Call(utils.CacheSv1HasItem, argHasItem, &reply); err != nil {
t.Error(err)
} else if !reply {
t.Errorf("Expected: %v , received:%v", expected, reply)
}
var rcvKeys []string
expKeys := []string{"cgrates.org:THD_TwoEnginesTest"}
argGetItemIDs := utils.ArgsGetCacheItemIDs{
CacheID: utils.CacheThresholdProfiles,
}
if err := engineOneRpc.Call(utils.CacheSv1GetItemIDs, argGetItemIDs, &rcvKeys); err != nil {
t.Fatalf("Got error on APIerSv1.GetCacheStats: %s ", err.Error())
} else if !reflect.DeepEqual(expKeys, rcvKeys) {
t.Errorf("Expected: %+v, received: %+v", expKeys, rcvKeys)
}
// func testTwoEnginesCheckCacheAfterSet(t *testing.T) {
// var reply bool
// expected := true
// argHasItem := utils.ArgsGetCacheItem{
// CacheID: utils.CacheThresholdProfiles,
// ItemID: "cgrates.org:THD_TwoEnginesTest",
// }
// if err := engineOneRpc.Call(utils.CacheSv1HasItem, argHasItem, &reply); err != nil {
// t.Error(err)
// } else if !reply {
// t.Errorf("Expected: %v , received:%v", expected, reply)
// }
// var rcvKeys []string
// expKeys := []string{"cgrates.org:THD_TwoEnginesTest"}
// argGetItemIDs := utils.ArgsGetCacheItemIDs{
// CacheID: utils.CacheThresholdProfiles,
// }
// if err := engineOneRpc.Call(utils.CacheSv1GetItemIDs, argGetItemIDs, &rcvKeys); err != nil {
// t.Fatalf("Got error on APIerSv1.GetCacheStats: %s ", err.Error())
// } else if !reflect.DeepEqual(expKeys, rcvKeys) {
// t.Errorf("Expected: %+v, received: %+v", expKeys, rcvKeys)
// }
if err := engineTwoRpc.Call(utils.CacheSv1HasItem, argHasItem, &reply); err != nil {
t.Error(err)
} else if !reply {
t.Errorf("Expected: %v , received:%v", expected, reply)
}
if err := engineTwoRpc.Call(utils.CacheSv1GetItemIDs, argGetItemIDs, &rcvKeys); err != nil {
t.Fatalf("Got error on APIerSv1.GetCacheStats: %s ", err.Error())
} else if !reflect.DeepEqual(expKeys, rcvKeys) {
t.Errorf("Expected: %+v, received: %+v", expKeys, rcvKeys)
}
// after we verify the cache make sure it was set correctly there
tPrfl := &engine.ThresholdProfileWithAPIOpts{
ThresholdProfile: &engine.ThresholdProfile{
Tenant: "cgrates.org",
ID: "THD_TwoEnginesTest",
FilterIDs: []string{"*string:~*req.Account:1001"},
MaxHits: -1,
MinSleep: 5 * time.Minute,
Blocker: false,
Weight: 20.0,
ActionProfileIDs: []string{"ACT_1"},
Async: true,
},
}
var rplTh *engine.ThresholdProfile
if err := engineTwoRpc.Call(utils.APIerSv1GetThresholdProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "THD_TwoEnginesTest"}, &rplTh); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(tPrfl.ThresholdProfile, rplTh) {
t.Errorf("Expecting: %+v, received: %+v", tPrfl.ThresholdProfile, rplTh)
}
}
// if err := engineTwoRpc.Call(utils.CacheSv1HasItem, argHasItem, &reply); err != nil {
// t.Error(err)
// } else if !reply {
// t.Errorf("Expected: %v , received:%v", expected, reply)
// }
// if err := engineTwoRpc.Call(utils.CacheSv1GetItemIDs, argGetItemIDs, &rcvKeys); err != nil {
// t.Fatalf("Got error on APIerSv1.GetCacheStats: %s ", err.Error())
// } else if !reflect.DeepEqual(expKeys, rcvKeys) {
// t.Errorf("Expected: %+v, received: %+v", expKeys, rcvKeys)
// }
// // after we verify the cache make sure it was set correctly there
// tPrfl := &engine.ThresholdProfileWithAPIOpts{
// ThresholdProfile: &engine.ThresholdProfile{
// Tenant: "cgrates.org",
// ID: "THD_TwoEnginesTest",
// FilterIDs: []string{"*string:~*req.Account:1001"},
// MaxHits: -1,
// MinSleep: 5 * time.Minute,
// Blocker: false,
// Weight: 20.0,
// ActionProfileIDs: []string{"ACT_1"},
// Async: true,
// },
// }
// var rplTh *engine.ThresholdProfile
// if err := engineTwoRpc.Call(utils.APIerSv1GetThresholdProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "THD_TwoEnginesTest"}, &rplTh); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(tPrfl.ThresholdProfile, rplTh) {
// t.Errorf("Expecting: %+v, received: %+v", tPrfl.ThresholdProfile, rplTh)
// }
// }
func testTwoEnginesUpdateThreshold(t *testing.T) {
var rplTh *engine.ThresholdProfile
var result string
tPrfl := &engine.ThresholdProfileWithAPIOpts{
ThresholdProfile: &engine.ThresholdProfile{
Tenant: "cgrates.org",
ID: "THD_TwoEnginesTest",
FilterIDs: []string{"*string:~*req.Account:10"},
MaxHits: -1,
MinSleep: time.Minute,
Blocker: false,
Weight: 50.0,
ActionProfileIDs: []string{"ACT_1.1"},
Async: true,
},
APIOpts: map[string]interface{}{
utils.CacheOpt: utils.MetaReload,
},
}
if err := engineOneRpc.Call(utils.APIerSv1SetThresholdProfile, tPrfl, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
if err := engineOneRpc.Call(utils.APIerSv1GetThresholdProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "THD_TwoEnginesTest"}, &rplTh); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(tPrfl.ThresholdProfile, rplTh) {
t.Errorf("Expecting: %+v, received: %+v", tPrfl.ThresholdProfile, rplTh)
}
if err := engineTwoRpc.Call(utils.APIerSv1GetThresholdProfile,
&utils.TenantID{Tenant: "cgrates.org", ID: "THD_TwoEnginesTest"}, &rplTh); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(tPrfl.ThresholdProfile, rplTh) {
t.Errorf("Expecting: %+v, received: %+v", tPrfl.ThresholdProfile, rplTh)
}
}
// func testTwoEnginesUpdateThreshold(t *testing.T) {
// var rplTh *engine.ThresholdProfile
// var result string
// tPrfl := &engine.ThresholdProfileWithAPIOpts{
// ThresholdProfile: &engine.ThresholdProfile{
// Tenant: "cgrates.org",
// ID: "THD_TwoEnginesTest",
// FilterIDs: []string{"*string:~*req.Account:10"},
// MaxHits: -1,
// MinSleep: time.Minute,
// Blocker: false,
// Weight: 50.0,
// ActionProfileIDs: []string{"ACT_1.1"},
// Async: true,
// },
// APIOpts: map[string]interface{}{
// utils.CacheOpt: utils.MetaReload,
// },
// }
// if err := engineOneRpc.Call(utils.APIerSv1SetThresholdProfile, tPrfl, &result); err != nil {
// t.Error(err)
// } else if result != utils.OK {
// t.Error("Unexpected reply returned", result)
// }
// if err := engineOneRpc.Call(utils.APIerSv1GetThresholdProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "THD_TwoEnginesTest"}, &rplTh); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(tPrfl.ThresholdProfile, rplTh) {
// t.Errorf("Expecting: %+v, received: %+v", tPrfl.ThresholdProfile, rplTh)
// }
// if err := engineTwoRpc.Call(utils.APIerSv1GetThresholdProfile,
// &utils.TenantID{Tenant: "cgrates.org", ID: "THD_TwoEnginesTest"}, &rplTh); err != nil {
// t.Error(err)
// } else if !reflect.DeepEqual(tPrfl.ThresholdProfile, rplTh) {
// t.Errorf("Expecting: %+v, received: %+v", tPrfl.ThresholdProfile, rplTh)
// }
// }
func testTwoEnginesKillEngines(t *testing.T) {
if err := engine.KillEngine(*waitRater); err != nil {
t.Error(err)
}
}
// func testTwoEnginesKillEngines(t *testing.T) {
// if err := engine.KillEngine(*waitRater); err != nil {
// t.Error(err)
// }
// }