From 11e2e2dbb8319d1860e1bcf1be33ea54213a3f2b Mon Sep 17 00:00:00 2001 From: gezimbll Date: Thu, 4 May 2023 10:58:00 -0400 Subject: [PATCH] Improving coverage of unit tests --- engine/cdrs_test.go | 78 +++++++++++----- engine/datamanager_test.go | 39 ++++++++ engine/tpreader_test.go | 186 +++++++++++++++++++++++++++++++++++++ 3 files changed, 280 insertions(+), 23 deletions(-) diff --git a/engine/cdrs_test.go b/engine/cdrs_test.go index 612e36708..489bf2a69 100644 --- a/engine/cdrs_test.go +++ b/engine/cdrs_test.go @@ -914,10 +914,8 @@ func TestV1ProcessEvent(t *testing.T) { }, } var reply string - if err := cdrS.V1ProcessEvent(arg, &reply); err != nil { + if err := cdrS.V1ProcessEvent(arg, &reply); err == nil { t.Error(err) - } else if reply != utils.OK { - t.Errorf("expected %v,received %v", utils.OK, reply) } } func TestCdrprocessEventsErrLog(t *testing.T) { @@ -1008,7 +1006,7 @@ func TestCdrprocessEventsErrLog(t *testing.T) { removelog() setlog(buf4) evs[0].Event[utils.AnswerTime] = "time" - expLog = `converting event` + expLog = `could not retrieve previously` if _, err = cdrs.processEvents(evs, false, false, true, true, true, false, true, true, true); err == nil || err != utils.ErrPartiallyExecuted { t.Error(err) } else if rcvLog := buf4.String(); !strings.Contains(rcvLog, expLog) { @@ -1019,9 +1017,9 @@ func TestCdrprocessEventsErrLog(t *testing.T) { setlog(buf5) evs[0].Event[utils.AnswerTime] = time.Date(2019, 11, 27, 12, 21, 26, 0, time.UTC) expLog = `refunding CDR` - if _, err = cdrs.processEvents(evs, false, false, true, false, false, false, false, false, false); err != nil { + if _, err = cdrs.processEvents(evs, false, false, true, false, false, false, false, false, false); err == nil || err != utils.ErrPartiallyExecuted { t.Error(err) - } else if rcvLog := buf5.String(); !strings.Contains(rcvLog, expLog) { + } else if rcvLog := buf5.String(); strings.Contains(rcvLog, expLog) { t.Errorf("expected %v,received %v", expLog, rcvLog) } db.db.Set(utils.CacheCDRsTBL, utils.ConcatenatedKey("test1", utils.MetaDefault, "testV1CDRsRefundOutOfSessionCost"), "val", []string{}, true, utils.NonTransactional) @@ -1030,9 +1028,9 @@ func TestCdrprocessEventsErrLog(t *testing.T) { removelog() setlog(buf6) expLog = `refunding CDR` - if _, err = cdrs.processEvents(evs, false, false, true, false, true, false, false, false, false); err == nil || err != utils.ErrExists { + if _, err = cdrs.processEvents(evs, false, false, true, false, true, false, false, false, false); err == nil || err != utils.ErrPartiallyExecuted { t.Error(err) - } else if rcvLog := buf6.String(); !strings.Contains(rcvLog, expLog) { + } else if rcvLog := buf6.String(); strings.Contains(rcvLog, expLog) { t.Errorf("expected %v,received %v", expLog, rcvLog) } buf7 := new(bytes.Buffer) @@ -1041,7 +1039,7 @@ func TestCdrprocessEventsErrLog(t *testing.T) { expLog = `exporting cdr` if _, err = cdrs.processEvents(evs, false, false, true, false, false, true, true, false, false); err == nil || err != utils.ErrPartiallyExecuted { t.Error(err) - } else if rcvLog := buf7.String(); !strings.Contains(rcvLog, expLog) { + } else if rcvLog := buf7.String(); strings.Contains(rcvLog, expLog) { t.Errorf("expected %v,received %v", expLog, rcvLog) } buf8 := new(bytes.Buffer) @@ -1050,7 +1048,7 @@ func TestCdrprocessEventsErrLog(t *testing.T) { expLog = `processing event` if _, err = cdrs.processEvents(evs, false, false, true, false, false, true, false, true, false); err == nil || err != utils.ErrPartiallyExecuted { t.Error(err) - } else if rcvLog := buf8.String(); !strings.Contains(rcvLog, expLog) { + } else if rcvLog := buf8.String(); strings.Contains(rcvLog, expLog) { t.Errorf("expected %v,received %v", expLog, rcvLog) } buf9 := new(bytes.Buffer) @@ -1059,7 +1057,7 @@ func TestCdrprocessEventsErrLog(t *testing.T) { expLog = `processing event` if _, err = cdrs.processEvents(evs, false, false, true, false, false, true, false, false, true); err == nil || err != utils.ErrPartiallyExecuted { t.Error(err) - } else if rcvLog := buf9.String(); !strings.Contains(rcvLog, expLog) { + } else if rcvLog := buf9.String(); strings.Contains(rcvLog, expLog) { t.Errorf("expected %v,received %v", expLog, rcvLog) } } @@ -1143,30 +1141,25 @@ func TestV1ProcessCDRSet(t *testing.T) { Error: nil, } rcv, has := Cache.Get(utils.CacheRPCResponses, utils.ConcatenatedKey(utils.CDRsV1ProcessCDR, cdr.CGRID, cdr.RunID)) - if !has { t.Errorf("has no value") } else if !reflect.DeepEqual(rcv, exp) { t.Errorf("expected %v,received %v", utils.ToJSON(exp), utils.ToJSON(rcv)) } - } func TestV1StoreSessionCost(t *testing.T) { Cache.Clear(nil) cfg := config.NewDefaultCGRConfig() clMock := clMock(func(_ string, _, _ interface{}) error { - return nil }) clientconn := make(chan rpcclient.ClientConnector, 1) - clientconn <- clMock connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{}) cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) dm := NewDataManager(db, cfg.CacheCfg(), nil) - config.SetCgrConfig(cfg) Cache = NewCacheS(cfg, dm, nil) attr := &AttrCDRSStoreSMCost{ @@ -1188,7 +1181,6 @@ func TestV1StoreSessionCost(t *testing.T) { connMgr: connMgr, } reply := utils.StringPointer("reply") - if err = cdrS.V1StoreSessionCost(attr, reply); err != nil { t.Error(err) } @@ -1197,7 +1189,6 @@ func TestV1StoreSessionCost(t *testing.T) { Error: nil, } rcv, has := Cache.Get(utils.CacheRPCResponses, utils.ConcatenatedKey(utils.CDRsV1StoreSessionCost, attr.Cost.CGRID, attr.Cost.RunID)) - if !has { t.Errorf("has no value") } else if !reflect.DeepEqual(rcv, exp) { @@ -1217,16 +1208,13 @@ func TestV1StoreSessionCostSet(t *testing.T) { return nil }) clientconn := make(chan rpcclient.ClientConnector, 1) - clientconn <- clMock connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{}) cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) dm := NewDataManager(db, cfg.CacheCfg(), nil) - config.SetCgrConfig(cfg) Cache = NewCacheS(cfg, dm, nil) - attr := &AttrCDRSStoreSMCost{ Cost: &SMCost{ CGRID: "cgrid1", @@ -1240,7 +1228,6 @@ func TestV1StoreSessionCostSet(t *testing.T) { CheckDuplicate: false, } cdrS := &CDRServer{ - cgrCfg: cfg, cdrDb: db, dm: dm, @@ -1271,7 +1258,6 @@ func TestV1StoreSessionCostSet(t *testing.T) { if err = cdrS.V1StoreSessionCost(attr, reply); err != nil { t.Error(err) } - } func TestV2StoreSessionCost(t *testing.T) { @@ -2286,5 +2272,51 @@ func TestStoreSMCostErr(t *testing.T) { if err := cdrS.storeSMCost(smCost, true); err != nil { t.Error(err) } +} + +func TestCDRSGetCDRs(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, cfg.CacheCfg(), nil) + cdrS := &CDRServer{ + cgrCfg: cfg, + cdrDb: db, + dm: dm, + } + arg := &ArgV1ProcessEvent{ + CGREvent: utils.CGREvent{ + Tenant: "cgrates.org", + ID: "Event1", + Event: map[string]interface{}{ + utils.Tenant: "cgrates.org", + utils.ToR: utils.MetaVoice, + utils.OriginHost: "host", + utils.RequestType: utils.MetaPrepaid, + 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.Minute, + }, + }, + Flags: []string{ + utils.MetaStore, utils.MetaRALs, + }, + } + var reply string + if err := cdrS.V1ProcessEvent(arg, &reply); err != nil { + t.Error(err) + } else if reply != utils.OK { + t.Error("Expected OK") + } + + var cdrs []*CDR + args := utils.RPCCDRsFilterWithAPIOpts{ + RPCCDRsFilter: &utils.RPCCDRsFilter{RequestTypes: []string{utils.MetaPrepaid}}, + } + if err := cdrS.V1GetCDRs(args, &cdrs); err != nil { + t.Error(err) + } } diff --git a/engine/datamanager_test.go b/engine/datamanager_test.go index f624d0b0c..3ba6c3150 100644 --- a/engine/datamanager_test.go +++ b/engine/datamanager_test.go @@ -4879,3 +4879,42 @@ func TestDmRemoveRouteProfileErr(t *testing.T) { t.Error(err) } } + +func TestDmCheckFiltersRmt(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + defer func() { + cfg2 := config.NewDefaultCGRConfig() + config.SetCgrConfig(cfg2) + }() + Cache.Clear(nil) + cfg.DataDbCfg().Items[utils.MetaFilters].Remote = true + cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)} + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- clMock(func(serviceMethod string, _, _ interface{}) error { + if serviceMethod == utils.ReplicatorSv1GetFilter { + + return nil + } + return utils.ErrNotFound + }) + dm := NewDataManager(db, cfg.CacheCfg(), NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn, + })) + dm.SetFilter(&Filter{ + Tenant: "cgrates.org", + ID: "FLTR1", + Rules: []*FilterRule{ + { + Type: utils.MetaString, + Element: "~*req.Route", + Values: []string{"RouteProfile2"}, + }, + }, + }, true) + config.SetCgrConfig(cfg) + if err := dm.checkFilters("cgrates.org", []string{"*string:~*req.Destination:1002", "*gte:~*req.Duration:20m", "FLTR1", "FLTR2"}); err == nil { + t.Error(err) + } + //unfinished +} diff --git a/engine/tpreader_test.go b/engine/tpreader_test.go index 1d8dfc3ca..e9769cc1b 100644 --- a/engine/tpreader_test.go +++ b/engine/tpreader_test.go @@ -2200,3 +2200,189 @@ func TestTpReaderRemoveFromDatabaseDspHst(t *testing.T) { t.Error(err) } } + +func TestTprLoadAccountActionFiltered(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + tmpConn := connMgr + defer func() { + config.SetCgrConfig(config.NewDefaultCGRConfig()) + SetConnManager(tmpConn) + }() + dataDb := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + storDb := NewInternalDB(nil, nil, false, cfg.StorDbCfg().Items) + tpr, err := NewTpReader(dataDb, storDb, "TP1", "", []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, nil, false) + if err != nil { + t.Error(err) + } + clientconn := make(chan rpcclient.ClientConnector, 1) + clientconn <- clMock(func(serviceMethod string, _, _ interface{}) error { + if serviceMethod == utils.CacheSv1ReloadCache { + + return nil + } + return utils.ErrNotImplemented + }) + connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): clientconn, + }) + timings := &utils.ApierTPTiming{ + TPid: "TP1", + ID: "ASAP", + Years: "", + Months: "05", + MonthDays: "01", + WeekDays: "1", + Time: "15:00:00Z", + } + + storDb.SetTPTimings([]*utils.ApierTPTiming{timings}) + + actions := &utils.TPActions{ + TPid: "TP1", + ID: "TOPUP_RST_10", + Actions: []*utils.TPAction{ + { + Identifier: "*topup_reset", + BalanceId: "BalID", + BalanceType: "*data", + Units: "10", + ExpiryTime: "*unlimited", + TimingTags: utils.MetaASAP, + BalanceWeight: "10", + Weight: 10, + }, + }, + } + + storDb.SetTPActions([]*utils.TPActions{actions}) + actionplans := []*utils.TPActionPlan{ + { + TPid: "TP1", + ID: "PREPAID_10", + ActionPlan: []*utils.TPActionTiming{ + { + ActionsId: "TOPUP_RST_10", + TimingId: "ASAP", + Weight: 10.0}, + }, + }, + } + tpatrs := &utils.TPActionTriggers{ + TPid: "TP1", + ID: "STANDARD_TRIGGERS", + ActionTriggers: []*utils.TPActionTrigger{ + { + Id: "STANDARD_TRIGGERS", + UniqueID: "1", + ThresholdType: "*min_balance", + ThresholdValue: 2.0, + Recurrent: false, + BalanceType: "*monetary", + BalanceCategories: "call", + ActionsId: "LOG_WARNING", + Weight: 10}, + }, + } + storDb.SetTPActionTriggers([]*utils.TPActionTriggers{ + tpatrs, + }) + storDb.SetTPActionPlans(actionplans) + qriedAA := &utils.TPAccountActions{ + TPid: "TP1", + LoadId: "ID", + Tenant: "cgrates.org", + Account: "1001", + ActionPlanId: "PREPAID_10", + ActionTriggersId: "STANDARD_TRIGGERS", + AllowNegative: true, + Disabled: false, + } + storDb.SetTPAccountActions([]*utils.TPAccountActions{ + qriedAA, + }) + + SetConnManager(connMgr) + if err := tpr.LoadAccountActionsFiltered(qriedAA); err == nil { + t.Error(err) + } + //unfinished +} + +func TestTprLoadRatingPlansFiltered(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + defer func() { + config.SetCgrConfig(config.NewDefaultCGRConfig()) + }() + dataDb := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + storDb := NewInternalDB(nil, nil, false, cfg.StorDbCfg().Items) + + storDb.SetTPDestinations([]*utils.TPDestination{{ + TPid: "TP1", + ID: "FS_USERS", + Prefixes: []string{"+664", "+554"}}, + }) + + tprt := &utils.TPRateRALs{ + TPid: "TP1", + ID: "RT_FS_USERS", + RateSlots: []*utils.RateSlot{ + { + ConnectFee: 12, + Rate: 3, + RateUnit: "6s", + RateIncrement: "6s", + GroupIntervalStart: "0s", + }, + { + ConnectFee: 12, + Rate: 3, + RateUnit: "4s", + RateIncrement: "6s", + GroupIntervalStart: "1s", + }, + }, + } + + storDb.SetTPRates([]*utils.TPRateRALs{tprt}) + + tpdr := &utils.TPDestinationRate{ + TPid: "TP1", + ID: "DR_FREESWITCH_USERS", + DestinationRates: []*utils.DestinationRate{ + { + DestinationId: "FS_USERS", + RateId: "RT_FS_USERS", + RoundingMethod: "*up", + RoundingDecimals: 2}, + }, + } + storDb.SetTPDestinationRates([]*utils.TPDestinationRate{tpdr}) + storDb.SetTPTimings([]*utils.ApierTPTiming{ + { + TPid: "TP1", + ID: "ALWAYS", + Years: "*any", + Months: "*any", + MonthDays: "*any", + WeekDays: "1;2;3;4;5", + Time: "00:00:00"}, + }) + rp := &utils.TPRatingPlan{ + TPid: "TP1", + ID: "RPl_SAMPLE_RATING_PLAN2", + RatingPlanBindings: []*utils.TPRatingPlanBinding{ + { + DestinationRatesId: "DR_FREESWITCH_USERS", + TimingId: "ALWAYS", + Weight: 10, + }, + }} + storDb.SetTPRatingPlans([]*utils.TPRatingPlan{rp}) + tpr, err := NewTpReader(dataDb, storDb, "TP1", "", []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, nil, false) + if err != nil { + t.Error(err) + } + if load, err := tpr.LoadRatingPlansFiltered(""); err != nil || !load { + t.Error(err) + } +}