mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
5f47df6927
Previously, database connections would stay alive until "go test" would finish, sometimes leading to max conn errors.
436 lines
16 KiB
Go
436 lines
16 KiB
Go
//go:build call
|
|
// +build call
|
|
|
|
/*
|
|
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
|
|
Copyright (C) ITsysCOM GmbH
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
package general_tests
|
|
|
|
import (
|
|
"os"
|
|
"path"
|
|
"reflect"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/cgrates/birpc/context"
|
|
"github.com/cgrates/birpc/jsonrpc"
|
|
"github.com/cgrates/cgrates/config"
|
|
"github.com/cgrates/cgrates/engine"
|
|
"github.com/cgrates/cgrates/sessions"
|
|
"github.com/cgrates/cgrates/utils"
|
|
)
|
|
|
|
func TestFsSessionOfflineInternal(t *testing.T) {
|
|
var cfgPath string
|
|
switch *utils.DBType {
|
|
case utils.MetaInternal:
|
|
cfgPath = path.Join(*utils.DataDir, "conf", "samples", "fs_offline_internal")
|
|
case utils.MetaMySQL:
|
|
cfgPath = path.Join(*utils.DataDir, "conf", "samples", "fs_offline_mysql")
|
|
case utils.MetaMongo, utils.MetaPostgres:
|
|
t.SkipNow()
|
|
default:
|
|
t.Fatal("Unknown Database type")
|
|
}
|
|
|
|
var err error
|
|
tutorialCallsCfg, err = config.NewCGRConfigFromPath(cfgPath)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if err = os.MkdirAll(tutorialCallsCfg.DataDbCfg().Opts.InternalDBDumpPath, 0700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = os.MkdirAll(tutorialCallsCfg.StorDbCfg().Opts.InternalDBDumpPath, 0700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
tutorialCallsCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush()
|
|
config.SetCgrConfig(tutorialCallsCfg)
|
|
engine.FlushDBs(t, tutorialCallsCfg, true, true)
|
|
engine.KillProcName(utils.Freeswitch, 5000)
|
|
if err := engine.CallScript(path.Join(*fsConfig, "freeswitch", "etc", "init.d", "freeswitch"), "start", 3000); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := engine.StopStartEngine(cfgPath, *utils.WaitRater); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
time.Sleep(500 * time.Millisecond)
|
|
tutorialCallsRpc, err = jsonrpc.Dial(utils.TCP, tutorialCallsCfg.ListenCfg().RPCJSONListen)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Run("LoadTPs", func(t *testing.T) {
|
|
var reply string
|
|
attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil {
|
|
t.Error(err)
|
|
}
|
|
time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups
|
|
})
|
|
|
|
t.Run("AccountsBefore", func(t *testing.T) {
|
|
var reply *engine.Account
|
|
attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.APIerSv2GetAccount, attrs, &reply); err != nil {
|
|
t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
|
|
} else if reply.BalanceMap[utils.MetaMonetary].GetTotalValue() != 10.0 {
|
|
t.Errorf("Calling APIerSv1.GetBalance received: %f", reply.BalanceMap[utils.MetaMonetary].GetTotalValue())
|
|
}
|
|
var reply2 *engine.Account
|
|
attrs2 := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1002"}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.APIerSv2GetAccount, attrs2, &reply2); err != nil {
|
|
t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
|
|
} else if reply2.BalanceMap[utils.MetaMonetary].GetTotalValue() != 10.0 {
|
|
t.Errorf("Calling APIerSv1.GetBalance received: %f", reply2.BalanceMap[utils.MetaMonetary].GetTotalValue())
|
|
}
|
|
var reply3 *engine.Account
|
|
attrs3 := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1003"}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.APIerSv2GetAccount, attrs3, &reply3); err != nil {
|
|
t.Error("Got error on APIerSv2.GetAccount: ", err.Error())
|
|
} else if reply3.BalanceMap[utils.MetaMonetary].GetTotalValue() != 10.0 {
|
|
t.Errorf("Calling APIerSv1.GetBalance received: %f", reply3.BalanceMap[utils.MetaMonetary].GetTotalValue())
|
|
}
|
|
})
|
|
|
|
t.Run("StatMetricsBefore", func(t *testing.T) {
|
|
var metrics map[string]string
|
|
expectedMetrics := map[string]string{
|
|
utils.MetaTCC: utils.NotAvailable,
|
|
utils.MetaTCD: utils.NotAvailable,
|
|
}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.StatSv1GetQueueStringMetrics,
|
|
&utils.TenantID{Tenant: "cgrates.org", ID: "Stats2"}, &metrics); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(expectedMetrics, metrics) {
|
|
t.Errorf("expecting: %+v, received reply: %s", expectedMetrics, metrics)
|
|
}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.StatSv1GetQueueStringMetrics,
|
|
&utils.TenantID{Tenant: "cgrates.org", ID: "Stats2_1"}, &metrics); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(expectedMetrics, metrics) {
|
|
t.Errorf("expecting: %+v, received reply: %s", expectedMetrics, metrics)
|
|
}
|
|
})
|
|
|
|
t.Run("CheckResourceBeforeAllocation", func(t *testing.T) {
|
|
var rs *engine.Resources
|
|
args := &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
ID: "ResourceEvent",
|
|
Event: map[string]any{
|
|
utils.AccountField: "1001",
|
|
utils.Subject: "1001",
|
|
utils.Destination: "1002",
|
|
},
|
|
APIOpts: map[string]any{
|
|
utils.OptsResourcesUsageID: "OriginID",
|
|
},
|
|
}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.ResourceSv1GetResourcesForEvent, args, &rs); err != nil {
|
|
t.Fatal(err)
|
|
} else if len(*rs) != 1 {
|
|
t.Fatalf("Resources: %+v", utils.ToJSON(rs))
|
|
}
|
|
for _, r := range *rs {
|
|
if r.ID == "ResGroup1" &&
|
|
(len(r.Usages) != 0 || len(r.TTLIdx) != 0) {
|
|
t.Errorf("Unexpected resource: %+v", utils.ToJSON(r))
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("CheckThresholdBefore", func(t *testing.T) {
|
|
var td engine.Threshold
|
|
eTd := engine.Threshold{Tenant: "cgrates.org", ID: "THD_ACNT_1001", Hits: 0}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.ThresholdSv1GetThreshold,
|
|
&utils.TenantID{Tenant: "cgrates.org", ID: "THD_ACNT_1001"}, &td); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(eTd, td) {
|
|
t.Errorf("expecting: %+v, received: %+v", eTd, td)
|
|
}
|
|
eTd = engine.Threshold{Tenant: "cgrates.org", ID: "THD_ACNT_1002", Hits: 0}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.ThresholdSv1GetThreshold,
|
|
&utils.TenantID{Tenant: "cgrates.org", ID: "THD_ACNT_1002"}, &td); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(eTd, td) {
|
|
t.Errorf("expecting: %+v, received: %+v", eTd, td)
|
|
}
|
|
})
|
|
|
|
t.Run("StartPjsuaListener", func(t *testing.T) {
|
|
var err error
|
|
acnts := []*engine.PjsuaAccount{
|
|
{Id: "sip:1001@127.0.0.1",
|
|
Username: "1001", Password: "CGRateS.org", Realm: "*", Registrar: "sip:127.0.0.1:5080"},
|
|
{Id: "sip:1002@127.0.0.1",
|
|
Username: "1002", Password: "CGRateS.org", Realm: "*", Registrar: "sip:127.0.0.1:5080"},
|
|
{Id: "sip:1003@127.0.0.1",
|
|
Username: "1003", Password: "CGRateS.org", Realm: "*", Registrar: "sip:127.0.0.1:5080"},
|
|
}
|
|
if tutorialCallsPjSuaListener, err = engine.StartPjsuaListener(
|
|
acnts, 5070, time.Duration(*utils.WaitRater)*time.Millisecond); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
time.Sleep(3 * time.Second)
|
|
})
|
|
|
|
t.Run("Call1001To1002", func(t *testing.T) {
|
|
if err := engine.PjsuaCallUri(
|
|
&engine.PjsuaAccount{Id: "sip:1001@127.0.0.1", Username: "1001", Password: "CGRateS.org", Realm: "*"},
|
|
"sip:1002@127.0.0.1", "sip:127.0.0.1:5080", 67*time.Second, 5071); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// give time to session to start so we can check it
|
|
time.Sleep(time.Second)
|
|
})
|
|
|
|
t.Run("GetActiveSessions", func(t *testing.T) {
|
|
var reply *[]*sessions.ExternalSession
|
|
expected := &[]*sessions.ExternalSession{
|
|
{
|
|
RequestType: "*prepaid",
|
|
Tenant: "cgrates.org",
|
|
Category: "call",
|
|
Account: "1001",
|
|
Subject: "1001",
|
|
Destination: "1002",
|
|
},
|
|
}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.SessionSv1GetActiveSessions,
|
|
nil, &reply); err != nil {
|
|
t.Error("Got error on SessionSv1.GetActiveSessions: ", err.Error())
|
|
} else {
|
|
if len(*reply) == 2 {
|
|
sort.Slice(*reply, func(i, j int) bool {
|
|
return strings.Compare((*reply)[i].RequestType, (*reply)[j].RequestType) > 0
|
|
})
|
|
}
|
|
// compare some fields (eg. CGRId is generated)
|
|
if !reflect.DeepEqual((*expected)[0].RequestType, (*reply)[0].RequestType) {
|
|
t.Errorf("Expected: %s, received: %s", (*expected)[0].RequestType, (*reply)[0].RequestType)
|
|
} else if !reflect.DeepEqual((*expected)[0].Account, (*reply)[0].Account) {
|
|
t.Errorf("Expected: %s, received: %s", (*expected)[0].Account, (*reply)[0].Account)
|
|
} else if !reflect.DeepEqual((*expected)[0].Destination, (*reply)[0].Destination) {
|
|
t.Errorf("Expected: %s, received: %s", (*expected)[0].Destination, (*reply)[0].Destination)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("CutEngineMidCall", func(t *testing.T) {
|
|
if err := engine.KillEngine(1000); err != nil {
|
|
t.Error(err)
|
|
}
|
|
// simulate connection down
|
|
time.Sleep(10 * time.Second)
|
|
})
|
|
|
|
t.Run("StartEngineMidCall", func(t *testing.T) {
|
|
if _, err := engine.StopStartEngine(cfgPath, *utils.WaitRater); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tutorialCallsRpc, err = jsonrpc.Dial(utils.TCP, tutorialCallsCfg.ListenCfg().RPCJSONListen) // We connect over JSON so we can also troubleshoot if needed
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
time.Sleep(23 * time.Second)
|
|
})
|
|
|
|
t.Run("CheckResourceAllocationAndWaitForCallToFinish", func(t *testing.T) {
|
|
var rs engine.Resources
|
|
args := &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
ID: "ResourceAllocation",
|
|
Event: map[string]any{
|
|
utils.AccountField: "1001",
|
|
utils.Subject: "1001",
|
|
utils.Destination: "1002",
|
|
},
|
|
APIOpts: map[string]any{
|
|
utils.OptsResourcesUsageID: "OriginID1",
|
|
},
|
|
}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.ResourceSv1GetResourcesForEvent, args, &rs); err != nil {
|
|
t.Fatal(err)
|
|
} else if len(rs) != 1 {
|
|
t.Fatalf("Resources: %+v", utils.ToJSON(rs))
|
|
}
|
|
if rs[0].ID != "ResGroup1" && len(rs[0].Usages) != 0 {
|
|
t.Errorf("Unexpected resource: %+v", utils.ToJSON(rs[0]))
|
|
}
|
|
// Allow calls to finish before start querying the results
|
|
time.Sleep(50 * time.Second)
|
|
})
|
|
|
|
t.Run("GetAccount1001", func(t *testing.T) {
|
|
var reply *engine.Account
|
|
attrs := &utils.AttrGetAccount{Tenant: "cgrates.org", Account: "1001"}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.APIerSv2GetAccount, attrs, &reply); err != nil {
|
|
t.Error(err.Error())
|
|
} else if reply.BalanceMap[utils.MetaMonetary].GetTotalValue() == 10.0 { // Make sure we debitted
|
|
t.Errorf("Expected: 10, received: %+v", reply.BalanceMap[utils.MetaMonetary].GetTotalValue())
|
|
} else if reply.Disabled == true {
|
|
t.Error("Account disabled")
|
|
}
|
|
})
|
|
|
|
t.Run("GetCDRs", func(t *testing.T) {
|
|
var reply []*engine.ExternalCDR
|
|
req := utils.RPCCDRsFilter{RunIDs: []string{utils.MetaDefault}, Accounts: []string{"1001"}}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.APIerSv2GetCDRs, &req, &reply); err != nil {
|
|
t.Error("Unexpected error: ", err.Error())
|
|
} else if len(reply) != 1 {
|
|
t.Error("Unexpected number of CDRs returned: ", len(reply))
|
|
} else {
|
|
for _, cdr := range reply {
|
|
if cdr.RequestType != utils.MetaPrepaid {
|
|
t.Errorf("Unexpected RequestType for CDR: %+v", cdr.RequestType)
|
|
}
|
|
if cdr.Destination == "1002" {
|
|
// in case of Asterisk take the integer part from usage
|
|
if optConf == utils.Asterisk {
|
|
cdr.Usage = strings.Split(cdr.Usage, ".")[0] + "s"
|
|
}
|
|
if cdr.Usage != "1m7s" && cdr.Usage != "1m8s" { // Usage as seconds
|
|
t.Errorf("Unexpected Usage for CDR: %+v", cdr.Usage)
|
|
}
|
|
if cdr.CostSource != utils.MetaSessionS {
|
|
t.Errorf("Unexpected CostSource for CDR: %+v", cdr.CostSource)
|
|
}
|
|
} else if cdr.Destination == "1003" {
|
|
// in case of Asterisk take the integer part from usage
|
|
if optConf == utils.Asterisk {
|
|
cdr.Usage = strings.Split(cdr.Usage, ".")[0] + "s"
|
|
}
|
|
if cdr.Usage != "12s" && cdr.Usage != "13s" { // Usage as seconds
|
|
t.Errorf("Unexpected Usage for CDR: %+v", cdr.Usage)
|
|
}
|
|
if cdr.CostSource != utils.MetaSessionS {
|
|
t.Errorf("Unexpected CostSource for CDR: %+v", cdr.CostSource)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("StatMetrics", func(t *testing.T) {
|
|
var metrics map[string]string
|
|
firstStatMetrics1 := map[string]string{
|
|
utils.MetaTCC: "0.6117",
|
|
utils.MetaTCD: "1m7s",
|
|
}
|
|
firstStatMetrics2 := map[string]string{
|
|
utils.MetaTCC: "1.35009",
|
|
utils.MetaTCD: "2m25s",
|
|
}
|
|
firstStatMetrics3 := map[string]string{
|
|
utils.MetaTCC: "1.34009",
|
|
utils.MetaTCD: "2m24s",
|
|
}
|
|
firstStatMetrics4 := map[string]string{
|
|
utils.MetaTCC: "1.35346",
|
|
utils.MetaTCD: "2m24s",
|
|
}
|
|
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.StatSv1GetQueueStringMetrics,
|
|
&utils.TenantID{Tenant: "cgrates.org", ID: "Stats2"}, &metrics); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(firstStatMetrics1, metrics) &&
|
|
!reflect.DeepEqual(firstStatMetrics2, metrics) &&
|
|
!reflect.DeepEqual(firstStatMetrics3, metrics) &&
|
|
!reflect.DeepEqual(firstStatMetrics4, metrics) {
|
|
t.Errorf("expecting: %+v, received reply: %s", firstStatMetrics1, metrics)
|
|
}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.StatSv1GetQueueStringMetrics,
|
|
&utils.TenantID{Tenant: "cgrates.org", ID: "Stats2_1"}, &metrics); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
t.Run("CheckResourceRelease", func(t *testing.T) {
|
|
var rs *engine.Resources
|
|
args := &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
ID: "ResourceRelease",
|
|
Event: map[string]any{
|
|
utils.AccountField: "1001",
|
|
utils.Subject: "1001",
|
|
utils.Destination: "1002",
|
|
},
|
|
APIOpts: map[string]any{
|
|
utils.OptsResourcesUsageID: "OriginID2",
|
|
},
|
|
}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.ResourceSv1GetResourcesForEvent, args, &rs); err != nil {
|
|
t.Fatal(err)
|
|
} else if len(*rs) != 1 {
|
|
t.Fatalf("Resources: %+v", rs)
|
|
}
|
|
for _, r := range *rs {
|
|
if r.ID == "ResGroup1" && len(r.Usages) != 0 {
|
|
t.Errorf("Unexpected resource: %+v", utils.ToJSON(r))
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("CheckThreshold1001After", func(t *testing.T) {
|
|
var td engine.Threshold
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.ThresholdSv1GetThreshold,
|
|
&utils.TenantID{Tenant: "cgrates.org", ID: "THD_ACNT_1001"}, &td); err != nil &&
|
|
err.Error() != utils.ErrNotFound.Error() {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
t.Run("CheckThreshold1002After", func(t *testing.T) {
|
|
var td engine.Threshold
|
|
eTd := engine.Threshold{Tenant: "cgrates.org", ID: "THD_ACNT_1002", Hits: 0}
|
|
if err := tutorialCallsRpc.Call(context.Background(), utils.ThresholdSv1GetThreshold,
|
|
&utils.TenantID{Tenant: "cgrates.org", ID: "THD_ACNT_1002"}, &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)
|
|
}
|
|
})
|
|
|
|
t.Run("StopPjsuaListener", func(t *testing.T) {
|
|
tutorialCallsPjSuaListener.Write([]byte("q\n")) // Close pjsua
|
|
time.Sleep(time.Second) // Allow pjsua to finish it's tasks, eg un-REGISTER
|
|
})
|
|
|
|
t.Run("StopCgrEngine", func(t *testing.T) {
|
|
if err := engine.KillEngine(100); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
|
|
t.Run("StopFS", func(t *testing.T) {
|
|
engine.ForceKillProcName(utils.Freeswitch, 1000)
|
|
})
|
|
if err := os.RemoveAll("/var/lib/cgrates/internal_db"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|