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

Add tpresources_it_test.go and refactoring tpstats_it_test.go with subtests

Browse Source
This commit is contained in:
TeoV
2017-09-04 06:31:20 -04:00
parent e6c97a6d59
commit f8fecaa314
5 changed files with 353 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
apier/v1/tpresources.go
View File

@@ -44,9 +44,10 @@ func (self *ApierV1) GetTPResource(attr AttrGetTPResource, reply *utils.TPResour
return utils.NewErrMandatoryIeMissing(missing...)
}
if rls, err := self.StorDb.GetTPResources(attr.TPid, attr.ID); err != nil {
return utils.NewErrServerError(err)
} else if len(rls) == 0 {
return utils.ErrNotFound
if err.Error() != utils.ErrNotFound.Error() {
err = utils.NewErrServerError(err)
}
return err
} else {
*reply = *rls[0]
}

217
apier/v1/tpresources_it_test.go Normal file
View File

@@ -0,0 +1,217 @@
// +build integration
/*
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 v1
import (
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
"net/rpc"
"net/rpc/jsonrpc"
"path"
"reflect"
"testing"
)
var (
tpResCfgPath string
tpResCfg *config.CGRConfig
tpResRPC *rpc.Client
tpResDataDir = "/usr/share/cgrates"
tpRes *utils.TPResource
tpResDelay int
tpResConfigDIR string //run tests for specific configuration
)
var sTestsTPResources = []func(t *testing.T){
testTPResInitCfg,
testTPResResetStorDb,
testTPResStartEngine,
testTPResRpcConn,
testTPResGetTPResourceBeforeSet,
testTPResSetTPResource,
testTPResGetTPResourceAfterSet,
testTPResUpdateTPResource,
testTPResGetTPResourceAfterUpdate,
testTPResRemTPResource,
testTPResGetTPResourceAfterRemove,
testTPResKillEngine,
}
//Test start here
func TestTPResITMySql(t *testing.T) {
tpResConfigDIR = "tutmysql"
for _, stest := range sTestsTPResources {
t.Run(tpResConfigDIR, stest)
}
}
func TestTPResITMongo(t *testing.T) {
tpResConfigDIR = "tutmongo"
for _, stest := range sTestsTPResources {
t.Run(tpResConfigDIR, stest)
}
}
func TestTPResITPG(t *testing.T) {
tpResConfigDIR = "tutpostgres"
for _, stest := range sTestsTPResources {
t.Run(tpResConfigDIR, stest)
}
}
func testTPResInitCfg(t *testing.T) {
var err error
tpResCfgPath = path.Join(tpResDataDir, "conf", "samples", tpResConfigDIR)
tpResCfg, err = config.NewCGRConfigFromFolder(tpResCfgPath)
if err != nil {
t.Error(err)
}
tpResCfg.DataFolderPath = tpResDataDir // Share DataFolderPath through config towards StoreDb for Flush()
config.SetCgrConfig(tpResCfg)
switch tpResConfigDIR {
case "tutmongo": // Mongo needs more time to reset db, need to investigate
tpResDelay = 4000
default:
tpResDelay = 1000
}
}
// Wipe out the cdr database
func testTPResResetStorDb(t *testing.T) {
if err := engine.InitStorDb(tpResCfg); err != nil {
t.Fatal(err)
}
}
// Start CGR Engine
func testTPResStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(tpResCfgPath, tpResDelay); err != nil {
t.Fatal(err)
}
}
// Connect rpc client to rater
func testTPResRpcConn(t *testing.T) {
var err error
tpResRPC, err = jsonrpc.Dial("tcp", tpResCfg.RPCJSONListen) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal(err)
}
}
func testTPResGetTPResourceBeforeSet(t *testing.T) {
var reply *utils.TPResource
if err := tpResRPC.Call("ApierV1.GetTPResource", AttrGetTPResource{TPid: "TPR1", ID: "Res"}, &reply); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
func testTPResSetTPResource(t *testing.T) {
tpRes = &utils.TPResource{
TPid: "TPR1",
ID: "Res",
Filters: []*utils.TPRequestFilter{
&utils.TPRequestFilter{
Type: "*string",
FieldName: "Account",
Values: []string{"1001", "1002"},
},
},
ActivationInterval: &utils.TPActivationInterval{
ActivationTime: "2014-07-29T15:00:00Z",
ExpiryTime: "",
},
UsageTTL: "1",
Limit: "1",
AllocationMessage: "Message",
Blocker: false,
Stored: false,
Weight: 20,
Thresholds: []string{"ValOne", "ValTwo"},
}
var result string
if err := tpResRPC.Call("ApierV1.SetTPResource", tpRes, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
}
func testTPResGetTPResourceAfterSet(t *testing.T) {
var respond *utils.TPResource
if err := tpResRPC.Call("ApierV1.GetTPResource", &AttrGetTPResource{TPid: tpRes.TPid, ID: tpRes.ID}, &respond); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(tpRes, respond) {
t.Errorf("Expecting : %+v, received: %+v", tpRes, respond)
}
}
func testTPResUpdateTPResource(t *testing.T) {
var result string
tpRes.Filters = []*utils.TPRequestFilter{
&utils.TPRequestFilter{
Type: "*string",
FieldName: "Account",
Values: []string{"1001", "1002"},
},
&utils.TPRequestFilter{
Type: "*string_prefix",
FieldName: "Destination",
Values: []string{"10", "20"},
},
}
if err := tpResRPC.Call("ApierV1.SetTPResource", tpRes, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
}
func testTPResGetTPResourceAfterUpdate(t *testing.T) {
var expectedTPR *utils.TPResource
if err := tpResRPC.Call("ApierV1.GetTPResource", &AttrGetTPResource{TPid: tpRes.TPid, ID: tpRes.ID}, &expectedTPR); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(tpRes, expectedTPR) {
t.Errorf("Expecting: %+v, received: %+v", tpRes, expectedTPR)
}
}
func testTPResRemTPResource(t *testing.T) {
var resp string
if err := tpResRPC.Call("ApierV1.RemTPResource", &AttrGetTPResource{TPid: tpRes.TPid, ID: tpRes.ID}, &resp); err != nil {
t.Error(err)
} else if resp != utils.OK {
t.Error("Unexpected reply returned", resp)
}
}
func testTPResGetTPResourceAfterRemove(t *testing.T) {
var respond *utils.TPResource
if err := tpResRPC.Call("ApierV1.GetTPResource", &AttrGetTPStat{TPid: "TPS1", ID: "Stat1"}, &respond); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
func testTPResKillEngine(t *testing.T) {
if err := engine.KillEngine(tpResDelay); err != nil {
t.Error(err)
}
}

169
apier/v1/tpstats_it_test.go
View File

@@ -30,99 +30,140 @@ import (
"testing"
)
var tpCfgPath string
var tpCfg *config.CGRConfig
var tpRPC *rpc.Client
var tpDataDir = "/usr/share/cgrates"
var (
tpStatCfgPath string
tpStatCfg *config.CGRConfig
tpStatRPC *rpc.Client
tpStatDataDir = "/usr/share/cgrates"
tpStat *utils.TPStats
tpStatDelay int
tpStatConfigDIR string //run tests for specific configuration
)
func TestTPStatInitCfg(t *testing.T) {
var sTestsTPStats = []func(t *testing.T){
testTPStatsInitCfg,
testTPStatsResetStorDb,
testTPStatsStartEngine,
testTPStatsRpcConn,
testTPStatsGetTPStatBeforeSet,
testTPStatsSetTPStat,
testTPStatsGetTPStatAfterSet,
testTPStatsUpdateTPStat,
testTPStatsGetTPStatAfterUpdate,
testTPStatsRemTPStat,
testTPStatsGetTPStatAfterRemove,
testTPStatsKillEngine,
}
//Test start here
func TestTPStatITMySql(t *testing.T) {
tpStatConfigDIR = "tutmysql"
for _, stest := range sTestsTPStats {
t.Run(tpStatConfigDIR, stest)
}
}
func TestTPStatITMongo(t *testing.T) {
tpStatConfigDIR = "tutmongo"
for _, stest := range sTestsTPStats {
t.Run(tpStatConfigDIR, stest)
}
}
func TestTPStatITPG(t *testing.T) {
tpStatConfigDIR = "tutpostgres"
for _, stest := range sTestsTPStats {
t.Run(tpStatConfigDIR, stest)
}
}
func testTPStatsInitCfg(t *testing.T) {
var err error
tpCfgPath = path.Join(tpDataDir, "conf", "samples", "tutmysql")
tpCfg, err = config.NewCGRConfigFromFolder(tpCfgPath)
tpStatCfgPath = path.Join(tpStatDataDir, "conf", "samples", tpStatConfigDIR)
tpStatCfg, err = config.NewCGRConfigFromFolder(tpStatCfgPath)
if err != nil {
t.Error(err)
}
tpCfg.DataFolderPath = tpDataDir // Share DataFolderPath through config towards StoreDb for Flush()
config.SetCgrConfig(tpCfg)
tpStatCfg.DataFolderPath = tpStatDataDir // Share DataFolderPath through config towards StoreDb for Flush()
config.SetCgrConfig(tpStatCfg)
switch tpStatConfigDIR {
case "tutmongo": // Mongo needs more time to reset db, need to investigate
tpStatDelay = 4000
default:
tpStatDelay = 1000
}
}
// Wipe out the cdr database
func TestTPStatResetStorDb(t *testing.T) {
if err := engine.InitStorDb(tpCfg); err != nil {
func testTPStatsResetStorDb(t *testing.T) {
if err := engine.InitStorDb(tpStatCfg); err != nil {
t.Fatal(err)
}
}
// Start CGR Engine
func TestTPStatStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(tpCfgPath, 1000); err != nil {
func testTPStatsStartEngine(t *testing.T) {
if _, err := engine.StopStartEngine(tpStatCfgPath, tpStatDelay); err != nil {
t.Fatal(err)
}
}
// Connect rpc client to rater
func TestTPStatRpcConn(t *testing.T) {
func testTPStatsRpcConn(t *testing.T) {
var err error
tpRPC, err = jsonrpc.Dial("tcp", tpCfg.RPCJSONListen) // We connect over JSON so we can also troubleshoot if needed
tpStatRPC, err = jsonrpc.Dial("tcp", tpStatCfg.RPCJSONListen) // We connect over JSON so we can also troubleshoot if needed
if err != nil {
t.Fatal(err)
}
}
var tpStat = &utils.TPStats{
TPid: "TPS1",
ID: "Stat1",
Filters: []*utils.TPRequestFilter{
&utils.TPRequestFilter{
Type: "*string",
FieldName: "Account",
Values: []string{"1001", "1002"},
},
&utils.TPRequestFilter{
Type: "*string_prefix",
FieldName: "Destination",
Values: []string{"10", "20"},
},
},
ActivationInterval: &utils.TPActivationInterval{
ActivationTime: "2014-07-29T15:00:00Z",
ExpiryTime: "",
},
TTL: "1",
Metrics: []string{"MetricValue", "MetricValueTwo"},
Blocker: true,
Stored: true,
Weight: 20,
Thresholds: nil,
}
func TestTPStatGetTPStatIDs(t *testing.T) {
var reply []string
if err := tpRPC.Call("ApierV1.GetTPStatIDs", AttrGetTPStatIds{TPid: "TPS1"}, &reply); err == nil || err.Error() != utils.ErrNotFound.Error() {
func testTPStatsGetTPStatBeforeSet(t *testing.T) {
var reply *utils.TPStats
if err := tpStatRPC.Call("ApierV1.GetTPStat", AttrGetTPStat{TPid: "TPS1", ID: "Stat1"}, &reply); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
func TestTPStatSetTPStat(t *testing.T) {
func testTPStatsSetTPStat(t *testing.T) {
tpStat = &utils.TPStats{
TPid: "TPS1",
ID: "Stat1",
Filters: []*utils.TPRequestFilter{
&utils.TPRequestFilter{
Type: "*string",
FieldName: "Account",
Values: []string{"1001", "1002"},
},
},
ActivationInterval: &utils.TPActivationInterval{
ActivationTime: "2014-07-29T15:00:00Z",
ExpiryTime: "",
},
TTL: "1",
Metrics: []string{"MetricValue", "MetricValueTwo"},
Blocker: false,
Stored: false,
Weight: 20,
Thresholds: []string{"ThreshValue", "ThreshValueTwo"},
}
var result string
if err := tpRPC.Call("ApierV1.SetTPStat", tpStat, &result); err != nil {
if err := tpStatRPC.Call("ApierV1.SetTPStat", tpStat, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
}
func TestTPStatGetTPStat(t *testing.T) {
func testTPStatsGetTPStatAfterSet(t *testing.T) {
var respond *utils.TPStats
if err := tpRPC.Call("ApierV1.GetTPStat", &AttrGetTPStat{TPid: tpStat.TPid, ID: tpStat.ID}, &respond); err != nil {
if err := tpStatRPC.Call("ApierV1.GetTPStat", &AttrGetTPStat{TPid: tpStat.TPid, ID: tpStat.ID}, &respond); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(tpStat, respond) {
t.Errorf("Expecting: %+v, received: %+v", tpStat.TPid, respond.TPid)
t.Errorf("Expecting: %+v, received: %+v", tpStat, respond)
}
}
func TestTPStatUpdateTPStat(t *testing.T) {
func testTPStatsUpdateTPStat(t *testing.T) {
var result string
tpStat.Weight = 21
tpStat.Filters = []*utils.TPRequestFilter{
@@ -136,43 +177,41 @@ func TestTPStatUpdateTPStat(t *testing.T) {
FieldName: "Destination",
Values: []string{"10", "20"},
},
&utils.TPRequestFilter{
Type: "*rsr_fields",
FieldName: "",
Values: []string{"Subject(~^1.*1$)", "Destination(1002)"},
},
}
if err := tpRPC.Call("ApierV1.SetTPStat", tpStat, &result); err != nil {
if err := tpStatRPC.Call("ApierV1.SetTPStat", tpStat, &result); err != nil {
t.Error(err)
} else if result != utils.OK {
t.Error("Unexpected reply returned", result)
}
}
func testTPStatsGetTPStatAfterUpdate(t *testing.T) {
var expectedTPS *utils.TPStats
if err := tpRPC.Call("ApierV1.GetTPStat", &AttrGetTPStat{TPid: tpStat.TPid, ID: tpStat.ID}, &expectedTPS); err != nil {
if err := tpStatRPC.Call("ApierV1.GetTPStat", &AttrGetTPStat{TPid: tpStat.TPid, ID: tpStat.ID}, &expectedTPS); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(tpStat, expectedTPS) {
t.Errorf("Expecting: %+v, received: %+v", tpStat, expectedTPS)
}
}
func TestTPStatRemTPStat(t *testing.T) {
func testTPStatsRemTPStat(t *testing.T) {
var resp string
if err := tpRPC.Call("ApierV1.RemTPStat", &AttrGetTPStat{TPid: tpStat.TPid, ID: tpStat.ID}, &resp); err != nil {
if err := tpStatRPC.Call("ApierV1.RemTPStat", &AttrGetTPStat{TPid: tpStat.TPid, ID: tpStat.ID}, &resp); err != nil {
t.Error(err)
} else if resp != utils.OK {
t.Error("Unexpected reply returned", resp)
}
}
func TestTPStatCheckDelete(t *testing.T) {
func testTPStatsGetTPStatAfterRemove(t *testing.T) {
var respond *utils.TPStats
if err := tpRPC.Call("ApierV1.GetTPStat", &AttrGetTPStat{TPid: "TPS1", ID: "Stat1"}, &respond); err == nil || err.Error() != utils.ErrNotFound.Error() {
if err := tpStatRPC.Call("ApierV1.GetTPStat", &AttrGetTPStat{TPid: "TPS1", ID: "Stat1"}, &respond); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Error(err)
}
}
func TestTPStatKillEngine(t *testing.T) {
if err := engine.KillEngine(100); err != nil {
func testTPStatsKillEngine(t *testing.T) {
if err := engine.KillEngine(tpStatDelay); err != nil {
t.Error(err)
}
}

35
engine/model_helpers.go
View File

@@ -1837,6 +1837,8 @@ func (tps TpResources) AsTPResources() (result []*utils.TPResource) {
if tp.AllocationMessage != "" {
rl.AllocationMessage = tp.AllocationMessage
}
rl.Blocker = tp.Blocker
rl.Stored = tp.Stored
if len(tp.ActivationInterval) != 0 {
rl.ActivationInterval = new(utils.TPActivationInterval)
aiSplt := strings.Split(tp.ActivationInterval, utils.INFIELD_SEP)
@@ -1884,6 +1886,8 @@ func APItoModelResource(rl *utils.TPResource) (mdls TpResources) {
mdl.Weight = rl.Weight
mdl.Limit = rl.Limit
mdl.AllocationMessage = rl.AllocationMessage
mdl.Blocker = rl.Blocker
mdl.Stored = rl.Stored
if rl.ActivationInterval != nil {
if rl.ActivationInterval.ActivationTime != "" {
mdl.ActivationInterval = rl.ActivationInterval.ActivationTime
@@ -1894,20 +1898,20 @@ func APItoModelResource(rl *utils.TPResource) (mdls TpResources) {
}
for i, val := range rl.Thresholds {
if i != 0 {
mdl.Thresholds = mdl.Thresholds + utils.INFIELD_SEP + val
} else {
mdl.Thresholds = val
mdl.Thresholds += utils.INFIELD_SEP
}
mdl.Thresholds += val
}
}
mdl.FilterType = fltr.Type
mdl.FilterFieldName = fltr.FieldName
for i, val := range fltr.Values {
if i != 0 {
mdl.FilterFieldValues = mdl.FilterFieldValues + utils.INFIELD_SEP + val
} else {
mdl.FilterFieldValues = val
mdl.FilterFieldValues += utils.INFIELD_SEP
}
mdl.FilterFieldValues += val
}
mdls = append(mdls, mdl)
}
@@ -1961,6 +1965,13 @@ func (tps TpStatsS) AsTPStats() (result []*utils.TPStats) {
Stored: tp.Stored,
}
}
if tp.Blocker == false || tp.Blocker == true {
st.Blocker = tp.Blocker
}
if tp.Stored == false || tp.Stored == true {
st.Stored = tp.Stored
}
if tp.QueueLength != 0 {
st.QueueLength = tp.QueueLength
}
@@ -2030,8 +2041,11 @@ func APItoModelStats(st *utils.TPStats) (mdls TpStatsS) {
}
mdl.Metrics += val
}
for _, val := range st.Thresholds {
mdl.Thresholds = mdl.Thresholds + utils.INFIELD_SEP + val
for i, val := range st.Thresholds {
if i != 0 {
mdl.Thresholds += utils.INFIELD_SEP
}
mdl.Thresholds += val
}
if st.ActivationInterval != nil {
if st.ActivationInterval.ActivationTime != "" {
@@ -2046,10 +2060,9 @@ func APItoModelStats(st *utils.TPStats) (mdls TpStatsS) {
mdl.FilterFieldName = fltr.FieldName
for i, val := range fltr.Values {
if i != 0 {
mdl.FilterFieldValues = mdl.FilterFieldValues + utils.INFIELD_SEP + val
} else {
mdl.FilterFieldValues = val
mdl.FilterFieldValues += utils.INFIELD_SEP
}
mdl.FilterFieldValues += val
}
mdls = append(mdls, mdl)
}

4
engine/stordb_it_test.go
View File

@@ -1440,6 +1440,8 @@ func testStorDBitCRUDTpResources(t *testing.T) {
Values: []string{"test1", "test2"},
},
},
Blocker: true,
Stored: true,
},
&utils.TPResource{
TPid: "testTPid",
@@ -1455,6 +1457,8 @@ func testStorDBitCRUDTpResources(t *testing.T) {
Values: []string{"test1", "test2"},
},
},
Blocker: true,
Stored: false,
},
}
if err := storDB.SetTPResources(snd); err != nil {