From 3e7775c6ef740331ac9172d24879405858740a07 Mon Sep 17 00:00:00 2001 From: ionutboangiu Date: Tue, 27 Apr 2021 19:33:10 +0300 Subject: [PATCH] Add tests for passTimings function in filters.go --- engine/filters_test.go | 265 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) diff --git a/engine/filters_test.go b/engine/filters_test.go index 6b9395615..06ad9269b 100644 --- a/engine/filters_test.go +++ b/engine/filters_test.go @@ -24,6 +24,7 @@ import ( "github.com/cgrates/baningo" "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/utils" + "github.com/cgrates/rpcclient" ) func TestFilterPassString(t *testing.T) { @@ -1619,3 +1620,267 @@ func TestAPIBan(t *testing.T) { t.Errorf("Expected error %s received: %v", expErr, err) } } + +// func TestFiltersPassTimings(t *testing.T) { +// tmp := connMgr +// defer func() { +// connMgr = tmp +// }() + +// // t.Run("Call is successful", func(t *testing.T) { + +// // cfg := config.NewDefaultCGRConfig() +// // cfg.FilterSCfg().ApierSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaApier)} +// // config.SetCgrConfig(cfg) +// // client := make(chan rpcclient.ClientConnector, 1) +// // ccM := &ccMock{ +// // calls: map[string]func(args interface{}, reply interface{}) error{ +// // utils.APIerSv1GetTiming: func(args, reply interface{}) error { +// // exp := &utils.TPTiming{ +// // ID: "MIDNIGHT", +// // Years: utils.Years{2020, 2018}, +// // Months: utils.Months{1, 2, 3, 4}, +// // MonthDays: utils.MonthDays{5, 6, 7, 8}, +// // WeekDays: utils.WeekDays{0, 1, 2, 3, 4, 5, 6}, +// // StartTime: "17:00:00", +// // EndTime: "17:00:18", +// // } +// // *reply.(*utils.TPTiming) = *exp +// // return nil +// // }, +// // }, +// // } +// // client <- ccM +// // NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ +// // utils.ConcatenatedKey(utils.MetaInternal, utils.MetaApier): client, +// // }) +// // fltr, err := NewFilterRule(utils.MetaTimings, "~*req.AnswerTime", []string{"2018-01-07T17:00:10Z"}) +// // if err != nil { +// // t.Fatal(err) +// // } +// // dtP := utils.MapStorage{ +// // utils.MetaReq: map[string]interface{}{ +// // "AnswerTime": "2018-01-07T17:00:10Z", +// // }, +// // } +// // rcv, err := fltr.passTimings(dtP) + +// // assertError(t, err, nil) +// // assertStatus(t, rcv, true) +// // }) + +// // t.Run("Failed to parse DataProvider: NOT_FOUND", func(t *testing.T) { +// // fltr, err := NewFilterRule(utils.MetaTimings, "~*req.AnswerTime", []string{"2018-01-07T17:00:10Z"}) +// // if err != nil { +// // t.Fatal(err) +// // } +// // dtP := utils.MapStorage{} +// // rcv, err := fltr.passTimings(dtP) + +// // assertError(t, err, nil) +// // assertStatus(t, rcv, false) +// // }) + +// // t.Run("Failed to parse DataProvider: WRONG_PATH", func(t *testing.T) { +// // fltr, err := NewFilterRule(utils.MetaTimings, "~*req.AnswerTime", []string{"2018-01-07T17:00:10Z"}) +// // if err != nil { +// // t.Fatal(err) +// // } +// // dtP := utils.MapStorage{ +// // utils.MetaReq: 13, +// // } +// // rcv, err := fltr.passTimings(dtP) +// // assertError(t, err, utils.ErrWrongPath) +// // assertStatus(t, rcv, false) +// // }) + +// // t.Run("Failed to convert to time.Time", func(t *testing.T) { +// // fltr, err := NewFilterRule(utils.MetaTimings, "~*req.AnswerTime", []string{"2018-01-07T17:00:10Z"}) +// // if err != nil { +// // t.Fatal(err) +// // } +// // dtP := utils.MapStorage{ +// // utils.MetaReq: map[string]interface{}{ +// // "AnswerTime": "invalid time", +// // }, +// // } +// // experr := errors.New("Unsupported time format") +// // rcv, err := fltr.passTimings(dtP) + +// // assertError(t, err, experr) +// // assertStatus(t, rcv, false) +// // }) + +// // t.Run("Failed to convert to time.Tim", func(t *testing.T) { +// // fltr, err := NewFilterRule(utils.MetaTimings, "~*req.AnswerTime", []string{"2018-01-07T17:00:10Z"}) +// // if err != nil { +// // t.Fatal(err) +// // } +// // dtP := utils.MapStorage{ +// // utils.MetaReq: map[string]interface{}{ +// // "AnswerTime": "2018-01-07T17:00:10Z", +// // }, +// // } +// // rcv, err := fltr.passTimings(dtP) + +// // assertError(t, err, nil) +// // assertStatus(t, rcv, false) +// // }) +// } + +// // func assertError(t testing.TB, received, expected error) { +// // t.Helper() +// // if expected != nil { +// // if received == nil || received.Error() != expected.Error() { +// // t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", expected, received) +// // } else { +// // if received != expected { +// // t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", expected, received) +// // } +// // } +// // } +// // } + +// // func assertStatus(t testing.TB, received, expected bool) { +// // t.Helper() +// // if received != expected { +// // t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", expected, received) +// // } +// // } +func TestFiltersPassTimingsParseFailNotFound(t *testing.T) { + fltr, err := NewFilterRule(utils.MetaTimings, "~*req.AnswerTime", []string{"2018-01-07T17:00:10Z"}) + if err != nil { + t.Fatal(err) + } + dtP := utils.MapStorage{} + rcv, err := fltr.passTimings(dtP) + + if err != nil { + t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", nil, err) + } + + if rcv != false { + t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", false, rcv) + } +} + +func TestFiltersPassTimingsParseFailWrongPath(t *testing.T) { + fltr, err := NewFilterRule(utils.MetaTimings, "~*req.AnswerTime", []string{"2018-01-07T17:00:10Z"}) + if err != nil { + t.Fatal(err) + } + dtP := utils.MapStorage{ + utils.MetaReq: 13, + } + + experr := utils.ErrWrongPath + rcv, err := fltr.passTimings(dtP) + + if err == nil || err != experr { + t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", experr, err) + } + + if rcv != false { + t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", false, rcv) + } +} + +func TestFiltersPassTimingsTimeConvertFail(t *testing.T) { + fltr, err := NewFilterRule(utils.MetaTimings, "~*req.AnswerTime", []string{"2018-01-07T17:00:10Z"}) + if err != nil { + t.Fatal(err) + } + dtP := utils.MapStorage{ + utils.MetaReq: map[string]interface{}{ + "AnswerTime": "invalid time", + }, + } + experr := "Unsupported time format" + rcv, err := fltr.passTimings(dtP) + + if err == nil || err.Error() != experr { + t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", experr, err) + } + + if rcv != false { + t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", false, rcv) + } +} + +func TestFiltersPassTimingsCallSuccessful(t *testing.T) { + tmp1, tmp2 := connMgr, config.CgrConfig() + defer func() { + connMgr = tmp1 + config.SetCgrConfig(tmp2) + }() + + cfg := config.NewDefaultCGRConfig() + cfg.FilterSCfg().ApierSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaApier)} + config.SetCgrConfig(cfg) + + client := make(chan rpcclient.ClientConnector, 1) + ccM := &ccMock{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.APIerSv1GetTiming: func(args, reply interface{}) error { + exp := &utils.TPTiming{ + ID: "MIDNIGHT", + Years: utils.Years{2020, 2018}, + Months: utils.Months{1, 2, 3, 4}, + MonthDays: utils.MonthDays{5, 6, 7, 8}, + WeekDays: utils.WeekDays{0, 1, 2, 3, 4, 5, 6}, + StartTime: "17:00:00", + EndTime: "17:00:18", + } + *reply.(*utils.TPTiming) = *exp + return nil + }, + }, + } + client <- ccM + + NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaApier): client, + }) + + fltr, err := NewFilterRule(utils.MetaTimings, "~*req.AnswerTime", []string{"2018-01-07T17:00:10Z"}) + if err != nil { + t.Fatal(err) + } + dtP := utils.MapStorage{ + utils.MetaReq: map[string]interface{}{ + "AnswerTime": "2018-01-07T17:00:10Z", + }, + } + + rcv, err := fltr.passTimings(dtP) + + if err != nil { + t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", nil, err) + } + + if rcv != true { + t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", true, rcv) + } +} + +func TestFiltersPassTimingsCallFail(t *testing.T) { + + fltr, err := NewFilterRule(utils.MetaTimings, "~*req.AnswerTime", []string{"2018-01-07T17:00:10Z"}) + if err != nil { + t.Fatal(err) + } + dtP := utils.MapStorage{ + utils.MetaReq: map[string]interface{}{ + "AnswerTime": "2018-01-07T17:00:10Z", + }, + } + rcv, err := fltr.passTimings(dtP) + + if err != nil { + t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", nil, err) + } + + if rcv != false { + t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", false, rcv) + } +}