From 47f1570e1c8a52d00ebab12cf43b58921e6316aa Mon Sep 17 00:00:00 2001 From: porosnicuadrian Date: Mon, 22 Feb 2021 17:54:52 +0200 Subject: [PATCH] Cover tests in sessions --- sessions/sessions.go | 3 - sessions/sessionscover_it_test.go | 472 +++++++++++++++++++++++++++++- 2 files changed, 467 insertions(+), 8 deletions(-) diff --git a/sessions/sessions.go b/sessions/sessions.go index 2d100c38b..6a88fc530 100644 --- a/sessions/sessions.go +++ b/sessions/sessions.go @@ -2268,9 +2268,6 @@ func (sS *SessionS) BiRPCv1InitiateSession(clnt rpcclient.ClientConnector, if !args.GetAttributes && !args.AllocateResources && !args.InitSession { return utils.NewErrMandatoryIeMissing("subsystems") } - if args.CGREvent.Tenant == "" { - args.CGREvent.Tenant = sS.cgrCfg.GeneralCfg().DefaultTenant - } originID, _ := args.CGREvent.FieldAsString(utils.OriginID) if args.GetAttributes { rplyAttr, err := sS.processAttributes(args.CGREvent, args.AttributeIDs, false) diff --git a/sessions/sessionscover_it_test.go b/sessions/sessionscover_it_test.go index 2b08891b8..7f176abed 100644 --- a/sessions/sessionscover_it_test.go +++ b/sessions/sessionscover_it_test.go @@ -82,7 +82,12 @@ var ( testBiRPCv1AuthorizeEvent, testBiRPCv1AuthorizeEvent2, testBiRPCv1AuthorizeEventWithDigest, - testBiRPCv1InitiateSession, + testBiRPCv1InitiateSession1, + testBiRPCv1InitiateSession2, + testBiRPCv1InitiateSessionWithDigest, + testBiRPCv1UpdateSession1, + testBiRPCv1UpdateSession2, + testBiRPCv1TerminateSession1, } ) @@ -2743,7 +2748,7 @@ func testBiRPCv1AuthorizeEventWithDigest(t *testing.T) { } } -func testBiRPCv1InitiateSession(t *testing.T) { +func testBiRPCv1InitiateSession1(t *testing.T) { tmp := engine.Cache engine.Cache.Clear(nil) @@ -2771,9 +2776,15 @@ func testBiRPCv1InitiateSession(t *testing.T) { return nil }, utils.ResourceSv1AllocateResources: func(args interface{}, reply interface{}) error { + if args.(*utils.ArgRSv1ResourceUsage).UsageID == "ORIGIN_ID" { + return utils.ErrNotImplemented + } return nil }, utils.AttributeSv1ProcessEvent: func(args interface{}, reply interface{}) error { + if len(args.(*engine.AttrArgsProcessEvent).AttributeIDs) != 0 { + return utils.ErrNotImplemented + } return nil }, }, @@ -2805,7 +2816,6 @@ func testBiRPCv1InitiateSession(t *testing.T) { nil, true) rply := &V1InitSessionReply{} - expected := "MANDATORY_IE_MISSING: [CGREvent]" if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err == nil || err.Error() != expected { t.Errorf("Expected %+v, received %+v", expected, err) @@ -2817,21 +2827,473 @@ func testBiRPCv1InitiateSession(t *testing.T) { } //get from cache error - cgrEvent.ID = "SESSIONS_ID_TEST" + cgrEvent.ID = "INITIATE_SESSION_ACTIVE" args = NewV1InitSessionArgs(true, []string{}, false, []string{}, false, []string{}, true, false, cgrEvent, true) caches := engine.NewCacheS(cfg, dm, nil) + //value's error will be nil, so the error of the initiate sessions will be the same value := &utils.CachedRPCResponse{ Result: &V1InitSessionReply{ ResourceAllocation: utils.StringPointer("ROUTE_LEASTCOST_1"), }, } engine.SetCache(caches) - caches.SetWithoutReplicate(utils.CacheRPCResponses, utils.ConcatenatedKey(utils.SessionSv1AuthorizeEvent, args.CGREvent.ID), + engine.Cache.SetWithoutReplicate(utils.CacheRPCResponses, utils.ConcatenatedKey(utils.SessionSv1InitiateSession, args.CGREvent.ID), value, nil, true, utils.NonTransactional) if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err != nil { t.Error(err) } engine.Cache = tmp + + args.CGREvent.Tenant = utils.EmptyString + args.AttributeIDs = []string{"attr1"} + expected = "ATTRIBUTES_ERROR:NOT_IMPLEMENTED" + if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } + + args.AllocateResources = true + args.AttributeIDs = []string{} + sessions.cgrCfg.SessionSCfg().ResSConns = []string{} + expected = "NOT_CONNECTED: ResourceS" + if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } + sessions.cgrCfg.SessionSCfg().ResSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaResources)} + + args = NewV1InitSessionArgs(true, []string{}, + false, []string{}, false, []string{}, true, false, + cgrEvent, true) + delete(args.CGREvent.Event, utils.OriginID) + expected = "MANDATORY_IE_MISSING: [OriginID]" + if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } + + cgrEvent = &utils.CGREvent{ + ID: "Test_id", + Tenant: "cgrates.org", + Event: map[string]interface{}{ + utils.Usage: "10s", + utils.OriginID: "ORIGIN_ID", + }, + } + args = NewV1InitSessionArgs(true, []string{}, + false, []string{}, false, []string{}, true, false, + cgrEvent, true) + expected = "RESOURCES_ERROR:NOT_IMPLEMENTED" + if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } + + //missing subsystems + args = NewV1InitSessionArgs(false, []string{}, + false, []string{}, false, []string{}, false, false, + cgrEvent, true) + expected = "MANDATORY_IE_MISSING: [subsystems]" + if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } +} + +func testBiRPCv1InitiateSession2(t *testing.T) { + engine.Cache.Clear(nil) + clnt := &testMockClients{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.ChargerSv1ProcessEvent: func(args interface{}, reply interface{}) error { + cghrgs := []*engine.ChrgSProcessEventReply{ + { + CGREvent: &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "TestID", + Event: map[string]interface{}{ + utils.Usage: "10s", + }, + }, + }, + } + *reply.(*[]*engine.ChrgSProcessEventReply) = cghrgs + return nil + }, + utils.ResourceSv1AuthorizeResources: func(args interface{}, reply interface{}) error { + if args.(*utils.ArgRSv1ResourceUsage).Tenant == "new_tenant" { + return utils.ErrNotImplemented + } + return nil + }, + utils.ThresholdSv1ProcessEvent: func(args interface{}, reply interface{}) error { + return utils.ErrNotImplemented + }, + }, + } + chanInternal := make(chan rpcclient.ClientConnector, 1) + chanInternal <- clnt + cfg := config.NewDefaultCGRConfig() + cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 + cfg.SessionSCfg().ThreshSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)} + cfg.SessionSCfg().ResSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaResources)} + data := engine.NewInternalDB(nil, nil, true) + connMgr := engine.NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers): chanInternal, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaResources): chanInternal, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds): chanInternal, + }) + dm := engine.NewDataManager(data, cfg.CacheCfg(), connMgr) + sessions := NewSessionS(cfg, dm, connMgr) + + cgrEvent := &utils.CGREvent{ + ID: "Test_id", + Tenant: "cgrates.org", + Event: map[string]interface{}{ + utils.Usage: "invalid_usage", + }, + Opts: map[string]interface{}{ + utils.OptsDebitInterval: "invalid_DUR_FORMAT", + }, + } + + args := NewV1InitSessionArgs(false, []string{}, + false, []string{}, false, []string{}, false, true, + cgrEvent, true) + + rply := &V1InitSessionReply{} + expected := "RALS_ERROR:time: invalid duration \"invalid_DUR_FORMAT\"" + if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } + args.CGREvent.Opts[utils.OptsDebitInterval] = "10s" + + expected = "ChargerS is disabled" + if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } + sessions.cgrCfg.SessionSCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers)} + + expected = "RALS_ERROR:time: invalid duration \"invalid_usage\"" + if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } + + sessions = NewSessionS(cfg, dm, connMgr) + args.CGREvent.Event[utils.Usage] = "10s" + if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err != nil { + t.Error(err) + } + + //here we process the thresholds + args = NewV1InitSessionArgs(false, []string{}, + true, []string{}, true, []string{}, false, true, + cgrEvent, true) + sessions = NewSessionS(cfg, dm, connMgr) + if err := sessions.BiRPCv1InitiateSession(nil, args, rply); err == nil || err != utils.ErrPartiallyExecuted { + t.Errorf("Expected %+v, received %+v", utils.ErrPartiallyExecuted, err) + } +} +func testBiRPCv1InitiateSessionWithDigest(t *testing.T) { + engine.Cache.Clear(nil) + clnt := &testMockClients{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.AttributeSv1ProcessEvent: func(args interface{}, reply interface{}) error { + cgrEv := engine.AttrSProcessEventReply{ + CGREvent: &utils.CGREvent{ + ID: "TestID", + Tenant: "cgrates.org", + Event: map[string]interface{}{}, + }, + } + *reply.(*engine.AttrSProcessEventReply) = cgrEv + return nil + }, + utils.ChargerSv1ProcessEvent: func(args interface{}, reply interface{}) error { + cghrgs := []*engine.ChrgSProcessEventReply{ + { + CGREvent: &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "TestID", + Event: map[string]interface{}{ + utils.Usage: "10s", + }, + }, + }, + } + *reply.(*[]*engine.ChrgSProcessEventReply) = cghrgs + return nil + }, + utils.ResourceSv1AllocateResources: func(args interface{}, reply interface{}) error { + return nil + }, + utils.RouteSv1GetRoutes: func(args interface{}, reply interface{}) error { + routesReply := engine.SortedRoutes{ + SortedRoutes: []*engine.SortedRoute{ + { + RouteID: "RouteID", + }, + }, + } + *reply.(*engine.SortedRoutes) = routesReply + return nil + }, + utils.ThresholdSv1ProcessEvent: func(args interface{}, reply interface{}) error { + return nil + }, + utils.StatSv1ProcessEvent: func(args interface{}, reply interface{}) error { + return nil + }, + }, + } + chanInternal := make(chan rpcclient.ClientConnector, 1) + chanInternal <- clnt + cfg := config.NewDefaultCGRConfig() + cfg.SessionSCfg().AttrSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes)} + cfg.SessionSCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers)} + cfg.SessionSCfg().ResSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaResources)} + cfg.SessionSCfg().RouteSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaRoutes)} + cfg.SessionSCfg().ThreshSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)} + cfg.SessionSCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats)} + cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 0 + data := engine.NewInternalDB(nil, nil, true) + connMgr := engine.NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers): chanInternal, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaResources): chanInternal, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaRoutes): chanInternal, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds): chanInternal, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes): chanInternal, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats): chanInternal, + }) + dm := engine.NewDataManager(data, cfg.CacheCfg(), connMgr) + sessions := NewSessionS(cfg, dm, connMgr) + + cgrEvent := &utils.CGREvent{ + Tenant: "cgrates.org", + Event: map[string]interface{}{ + utils.Usage: "10s", + utils.OriginID: "ORIGIND_ID", + }, + } + + args := NewV1InitSessionArgs(true, []string{}, + true, []string{}, true, []string{}, true, true, + cgrEvent, true) + + authReply := new(V1InitReplyWithDigest) + expectedRply := &V1InitReplyWithDigest{ + AttributesDigest: utils.StringPointer(utils.EmptyString), + ResourceAllocation: utils.StringPointer(utils.EmptyString), + MaxUsage: 10800, + Thresholds: utils.StringPointer(utils.EmptyString), + StatQueues: utils.StringPointer(utils.EmptyString), + } + if err := sessions.BiRPCv1InitiateSessionWithDigest(nil, args, authReply); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(authReply, expectedRply) { + t.Errorf("Expected %+v, received %+v", utils.ToJSON(expectedRply), utils.ToJSON(authReply)) + } + + sessions.cgrCfg.SessionSCfg().ChargerSConns = nil + expected := "MANDATORY_IE_MISSING: [OriginID]" + if err := sessions.BiRPCv1InitiateSessionWithDigest(nil, args, authReply); err == nil || err.Error() != expected { + t.Errorf("Expected %+v, received %+v", expected, err) + } +} + +func testBiRPCv1UpdateSession1(t *testing.T) { + tmp := engine.Cache + + engine.Cache.Clear(nil) + clnt := &testMockClients{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.AttributeSv1ProcessEvent: func(args interface{}, reply interface{}) error { + if len(args.(*engine.AttrArgsProcessEvent).AttributeIDs) == 1 { + return utils.ErrNotImplemented + } + return nil + }, + }, + } + chanInternal := make(chan rpcclient.ClientConnector, 1) + chanInternal <- clnt + cfg := config.NewDefaultCGRConfig() + cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 + cfg.SessionSCfg().AttrSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes)} + data := engine.NewInternalDB(nil, nil, true) + connMgr := engine.NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes): chanInternal, + }) + dm := engine.NewDataManager(data, cfg.CacheCfg(), connMgr) + sessions := NewSessionS(cfg, dm, connMgr) + + cgrEvent := &utils.CGREvent{ + Event: map[string]interface{}{ + utils.Usage: "10s", + utils.OriginID: "TEST_ID", + }, + } + args := NewV1UpdateSessionArgs(true, []string{}, false, + nil, true) + rply := new(V1UpdateSessionReply) + + expected := "MANDATORY_IE_MISSING: [CGREvent]" + if err := sessions.BiRPCv1UpdateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Exepected %+v, received %+v", expected, err) + } + + caches := engine.NewCacheS(cfg, dm, nil) + //value's error will be nil, so the error of the initiate sessions will be the same + value := &utils.CachedRPCResponse{ + Result: &V1UpdateSessionReply{ + MaxUsage: utils.DurationPointer(time.Minute), + }, + } + cgrEvent.ID = "test_id" + args = NewV1UpdateSessionArgs(true, []string{}, false, + cgrEvent, true) + engine.SetCache(caches) + engine.Cache.SetWithoutReplicate(utils.CacheRPCResponses, utils.ConcatenatedKey(utils.SessionSv1UpdateSession, args.CGREvent.ID), + value, nil, true, utils.NonTransactional) + if err := sessions.BiRPCv1UpdateSession(nil, args, rply); err != nil { + t.Error(err) + } + engine.Cache = tmp + + cgrEvent.ID = utils.EmptyString + args = NewV1UpdateSessionArgs(true, []string{"attrr1"}, false, + cgrEvent, true) + expected = "ATTRIBUTES_ERROR:NOT_IMPLEMENTED" + if err := sessions.BiRPCv1UpdateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Exepected %+v, received %+v", expected, err) + } + + args = NewV1UpdateSessionArgs(true, []string{}, false, + cgrEvent, true) + if err := sessions.BiRPCv1UpdateSession(nil, args, rply); err != nil { + t.Error(err) + } + + args = NewV1UpdateSessionArgs(false, []string{}, false, + cgrEvent, true) + expected = "MANDATORY_IE_MISSING: [subsystems]" + if err := sessions.BiRPCv1UpdateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Exepected %+v, received %+v", expected, err) + } +} + +func testBiRPCv1UpdateSession2(t *testing.T) { + engine.Cache.Clear(nil) + clnt := &testMockClients{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.ChargerSv1ProcessEvent: func(args interface{}, reply interface{}) error { + cghrgs := []*engine.ChrgSProcessEventReply{ + { + CGREvent: &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "TestID", + Event: map[string]interface{}{ + utils.Usage: "10s", + }, + }, + }, + } + *reply.(*[]*engine.ChrgSProcessEventReply) = cghrgs + return nil + }, + }, + } + chanInternal := make(chan rpcclient.ClientConnector, 1) + chanInternal <- clnt + cfg := config.NewDefaultCGRConfig() + data := engine.NewInternalDB(nil, nil, true) + connMgr := engine.NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers): chanInternal, + }) + dm := engine.NewDataManager(data, cfg.CacheCfg(), connMgr) + sessions := NewSessionS(cfg, dm, connMgr) + + cgrEvent := &utils.CGREvent{ + ID: "test_id", + Event: map[string]interface{}{ + utils.Usage: "invalid_dur_format", + utils.OriginID: "TEST_ID", + }, + Opts: map[string]interface{}{ + utils.OptsDebitInterval: "invalid_dur_format", + }, + } + args := NewV1UpdateSessionArgs(false, []string{}, true, + cgrEvent, true) + rply := new(V1UpdateSessionReply) + expected := "RALS_ERROR:time: invalid duration \"invalid_dur_format\"" + if err := sessions.BiRPCv1UpdateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Exepected %+v, received %+v", expected, err) + } + cgrEvent.Opts[utils.OptsDebitInterval] = "10s" + + args = NewV1UpdateSessionArgs(false, []string{}, true, + cgrEvent, true) + expected = "ChargerS is disabled" + if err := sessions.BiRPCv1UpdateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Exepected %+v, received %+v", expected, err) + } + sessions.cgrCfg.SessionSCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers)} + + expected = "RALS_ERROR:time: invalid duration \"invalid_dur_format\"" + if err := sessions.BiRPCv1UpdateSession(nil, args, rply); err == nil || err.Error() != expected { + t.Errorf("Exepected %+v, received %+v", expected, err) + } + + cgrEvent.Event[utils.Usage] = time.Minute + args = NewV1UpdateSessionArgs(false, []string{}, true, + cgrEvent, true) + if err := sessions.BiRPCv1UpdateSession(nil, args, rply); err != nil { + t.Error(err) + } +} + +func testBiRPCv1TerminateSession1(t *testing.T) { + engine.Cache.Clear(nil) + clnt := &testMockClients{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.ChargerSv1ProcessEvent: func(args interface{}, reply interface{}) error { + cghrgs := []*engine.ChrgSProcessEventReply{ + { + CGREvent: &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "TestID", + Event: map[string]interface{}{ + utils.Usage: "10s", + }, + }, + }, + } + *reply.(*[]*engine.ChrgSProcessEventReply) = cghrgs + return nil + }, + }, + } + chanInternal := make(chan rpcclient.ClientConnector, 1) + chanInternal <- clnt + cfg := config.NewDefaultCGRConfig() + cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 + cfg.SessionSCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers)} + data := engine.NewInternalDB(nil, nil, true) + connMgr := engine.NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers): chanInternal, + }) + dm := engine.NewDataManager(data, cfg.CacheCfg(), connMgr) + sessions := NewSessionS(cfg, dm, connMgr) + + cgrEvent := &utils.CGREvent{ + ID: "test_id", + Event: map[string]interface{}{ + utils.Usage: "10s", + utils.OriginID: "TEST_ID", + }, + } + args := NewV1TerminateSessionArgs(true, false, false, nil, false, nil, cgrEvent, true) + var reply string + expected := "" + if err := sessions.BiRPCv1TerminateSession(nil, args, &reply); err == nil || err.Error() != expected { + t.Errorf("Exepected %+v, received %+v", expected, err) + } + }