From f8fecaa3146471bbaabcba5b3574e68f3135dc6a Mon Sep 17 00:00:00 2001 From: TeoV Date: Mon, 4 Sep 2017 06:31:20 -0400 Subject: [PATCH] Add tpresources_it_test.go and refactoring tpstats_it_test.go with subtests --- apier/v1/tpresources.go | 7 +- apier/v1/tpresources_it_test.go | 217 ++++++++++++++++++++++++++++++++ apier/v1/tpstats_it_test.go | 169 +++++++++++++++---------- engine/model_helpers.go | 35 ++++-- engine/stordb_it_test.go | 4 + 5 files changed, 353 insertions(+), 79 deletions(-) create mode 100644 apier/v1/tpresources_it_test.go diff --git a/apier/v1/tpresources.go b/apier/v1/tpresources.go index 788806861..4be74cd37 100644 --- a/apier/v1/tpresources.go +++ b/apier/v1/tpresources.go @@ -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] } diff --git a/apier/v1/tpresources_it_test.go b/apier/v1/tpresources_it_test.go new file mode 100644 index 000000000..d257cc8d9 --- /dev/null +++ b/apier/v1/tpresources_it_test.go @@ -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 +*/ +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) + } +} diff --git a/apier/v1/tpstats_it_test.go b/apier/v1/tpstats_it_test.go index c27b25bdf..8c39b9539 100644 --- a/apier/v1/tpstats_it_test.go +++ b/apier/v1/tpstats_it_test.go @@ -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) } } diff --git a/engine/model_helpers.go b/engine/model_helpers.go index 45e156624..509b943a5 100755 --- a/engine/model_helpers.go +++ b/engine/model_helpers.go @@ -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) } diff --git a/engine/stordb_it_test.go b/engine/stordb_it_test.go index 47c785177..c3dbdd0cb 100755 --- a/engine/stordb_it_test.go +++ b/engine/stordb_it_test.go @@ -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 {