diff --git a/agents/agentreq_test.go b/agents/agentreq_test.go index d9f651a6f..5650466f1 100644 --- a/agents/agentreq_test.go +++ b/agents/agentreq_test.go @@ -2729,3 +2729,90 @@ func TestAgentRequestParseFieldDateTimeError2(t *testing.T) { t.Errorf("Expected <%+v> but received <%+v>", expected, err) } } + +func TestAgentRequestRemoveAll(t *testing.T) { + tntTpl := config.NewRSRParsersMustCompile("", utils.InfieldSep) + AgentReq := NewAgentRequest(utils.MapStorage{}, nil, nil, nil, nil, tntTpl, "", "", nil, nil) + + testCases := []struct { + prefix string + isError bool + }{ + {prefix: utils.MetaVars, isError: false}, + {prefix: utils.MetaCgreq, isError: false}, + {prefix: utils.MetaCgrep, isError: false}, + {prefix: utils.MetaRep, isError: false}, + {prefix: utils.MetaDiamreq, isError: false}, + {prefix: utils.MetaTmp, isError: false}, + {prefix: utils.MetaUCH, isError: false}, + {prefix: utils.MetaOpts, isError: false}, + {prefix: "unsupported_prefix", isError: true}, + } + + for _, testCase := range testCases { + err := AgentReq.RemoveAll(testCase.prefix) + if testCase.isError && err == nil { + t.Fatalf("expected an error for prefix: <%s>, but got no error", testCase.prefix) + } + if !testCase.isError && err != nil { + t.Fatalf("expected no error for prefix: <%s>, but got error: %v", testCase.prefix, err) + } + } +} + +func TestAgentRequestRemove(t *testing.T) { + tntTpl := config.NewRSRParsersMustCompile("", utils.InfieldSep) + AgentReq := NewAgentRequest(utils.MapStorage{}, nil, nil, nil, utils.MapStorage{utils.AccountField: "Field1"}, tntTpl, "", "", nil, nil) + testCases := []struct { + fullPath *utils.FullPath + isError bool + }{ + {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaVars}, Path: utils.MetaVars + utils.NestingSep + utils.AccountField}, isError: false}, + {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaCgreq}, Path: utils.MetaCgreq + utils.NestingSep + utils.Usage}, isError: false}, + {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaCgrep}}, isError: false}, + {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaRep}, Path: utils.MetaRep + utils.NestingSep + "MaxUsage"}, isError: false}, + {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaDiamreq}, Path: utils.MetaDiamreq + utils.NestingSep + "Destination-Host"}, isError: false}, + {fullPath: &utils.FullPath{PathSlice: []string{"unsupported_prefix"}}, isError: true}, + } + + for _, testCase := range testCases { + err := AgentReq.Remove(testCase.fullPath) + if testCase.isError && err == nil { + t.Fatalf("expected an error for fullPath: <%v>, but got no error", testCase.fullPath) + } + if !testCase.isError && err != nil { + t.Fatalf("expected no error for fullPath: <%v>, but got error: %v", testCase.fullPath, err) + } + } +} + +// func TestAgentRequestAppend(t *testing.T) { +// tntTpl := config.NewRSRParsersMustCompile("", utils.InfieldSep) +// ar := NewAgentRequest(utils.MapStorage{}, &utils.DataNode{Type: utils.NMMapType, Map: map[string]*utils.DataNode{ +// utils.MetaAppID: utils.NewLeafNode("appID")}}, nil, nil, utils.MapStorage{utils.AccountField: "Field1"}, tntTpl, "", "", nil, nil) +// testCases := []struct { +// fullPath *utils.FullPath +// val *utils.DataLeaf +// isError bool +// }{ +// {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaVars}}, val: &utils.DataLeaf{Data: "test"}, isError: false}, +// {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaCgreq}}, val: &utils.DataLeaf{Data: "test"}, isError: false}, +// {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaCgrep}}, val: &utils.DataLeaf{Data: "test"}, isError: false}, +// {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaRep}}, val: &utils.DataLeaf{Data: "test"}, isError: false}, +// {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaDiamreq}}, val: &utils.DataLeaf{Data: "test"}, isError: false}, +// {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaTmp}}, val: &utils.DataLeaf{Data: "test"}, isError: false}, +// {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaOpts}}, val: &utils.DataLeaf{Data: "test"}, isError: false}, +// {fullPath: &utils.FullPath{PathSlice: []string{utils.MetaUCH}}, val: &utils.DataLeaf{Data: "test"}, isError: false}, +// {fullPath: &utils.FullPath{PathSlice: []string{"unsupported_prefix"}}, val: &utils.DataLeaf{Data: "test"}, isError: true}, +// } + +// for _, testCase := range testCases { +// err := ar.Append(testCase.fullPath, testCase.val) +// if testCase.isError && err == nil { +// t.Fatalf("expected an error for fullPath: <%v>, but got no error", testCase.fullPath) +// } +// if !testCase.isError && err != nil { +// t.Fatalf("expected no error for fullPath: <%v>, but got error: %v", testCase.fullPath, err) +// } +// } +// } diff --git a/agents/asterisk_event_test.go b/agents/asterisk_event_test.go index a274bf6b0..347d3c389 100644 --- a/agents/asterisk_event_test.go +++ b/agents/asterisk_event_test.go @@ -475,3 +475,55 @@ func TestRequestType(t *testing.T) { t.Error("Received:", smaEv.RequestType()) } } + +func TestSMAsteriskEventUpdateCGREvent(t *testing.T) { + cgrEv := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "event1", + Event: make(map[string]interface{}), + } + + testCases := []struct { + smaEv *SMAsteriskEvent + wantErr bool + eventName string + }{ + { + smaEv: &SMAsteriskEvent{ + cachedFields: map[string]string{ + eventType: ARIChannelStateChange, + timestamp: "2023-05-05T10:00:00Z", + }, + }, + wantErr: false, + eventName: SMASessionStart, + }, + { + smaEv: &SMAsteriskEvent{ + cachedFields: map[string]string{ + eventType: ARIChannelDestroyed, + timestamp: "2023-05-05T10:00:00Z", + }, + }, + wantErr: false, + eventName: SMASessionTerminate, + }, + } + + for _, testCase := range testCases { + err := testCase.smaEv.UpdateCGREvent(cgrEv) + if testCase.wantErr && err == nil { + t.Fatal("expected an error, but got no error") + } + if !testCase.wantErr && err != nil { + t.Fatalf("expected no error, but got error: %v", err) + } + + if !testCase.wantErr { + if eventName, ok := cgrEv.Event[utils.EventName]; !ok || eventName != testCase.eventName { + t.Fatalf("expected event name: %s, but got: %v", testCase.eventName, eventName) + } + } + + } +} diff --git a/engine/datamanager_test.go b/engine/datamanager_test.go index 3ba6c3150..866dd3aa3 100644 --- a/engine/datamanager_test.go +++ b/engine/datamanager_test.go @@ -4918,3 +4918,65 @@ func TestDmCheckFiltersRmt(t *testing.T) { } //unfinished } + +func TestDmRebuildReverseForPrefix(t *testing.T) { + testCases := []struct { + desc string + prefix string + expectErr bool + }{ + { + desc: "Valid prefix - ReverseDestinationPrefix", + prefix: utils.ReverseDestinationPrefix, + expectErr: false, + }, + { + desc: "Valid prefix - AccountActionPlansPrefix", + prefix: utils.AccountActionPlansPrefix, + expectErr: false, + }, + { + desc: "Invalid prefix", + prefix: "invalid_prefix", + expectErr: true, + }, + } + cfg := config.NewDefaultCGRConfig() + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, cfg.CacheCfg(), nil) + dm.SetDestination(&Destination{ + Id: "Dest", + Prefixes: []string{"1001", "1002"}, + }, "") + + apls := []*ActionPlan{ + { + Id: "DisableBal", + AccountIDs: utils.StringMap{"cgrates:1001": true}, + }, + { + Id: "MoreMinutes", + AccountIDs: utils.StringMap{"cgrates:1002": true}, + }, + } + dm.SetAccount(&Account{ID: "cgrates:org:1001"}) + dm.SetAccount(&Account{ID: "cgrates:org:1002"}) + for _, apl := range apls { + dm.SetActionPlan(apl.Id, apl, true, "") + + } + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + err := dm.RebuildReverseForPrefix(tc.prefix) + if tc.expectErr { + if err == nil { + t.Fatal("Expected error, got nil") + } + } else { + if err != nil { + t.Fatalf("Expected no error, got: %v", err) + } + } + }) + } +} diff --git a/engine/routes_test.go b/engine/routes_test.go index 9109d8495..ae8badc20 100644 --- a/engine/routes_test.go +++ b/engine/routes_test.go @@ -2181,3 +2181,66 @@ func TestV1GetRoutesList(t *testing.T) { } } + +func TestRoutesV1GetRoutes(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, cfg.CacheCfg(), nil) + rpS := NewRouteService(dm, NewFilterS(cfg, nil, dm), cfg, nil) + + var reply []*RouteProfile + fltr := &Filter{ + Tenant: "cgrates.org", + ID: "FLT1", + Rules: []*FilterRule{ + { + Type: utils.MetaString, + Element: "~*req.Account", + Values: []string{"1003"}, + }, + }, + } + dm.SetFilter(fltr, true) + rpp := &RouteProfile{ + Tenant: "cgrates.org", + ID: "ROUTE1", + FilterIDs: []string{"FLT1"}, + ActivationInterval: &utils.ActivationInterval{ + ActivationTime: time.Date(2022, 11, 27, 0, 0, 0, 0, time.UTC), + }, + Sorting: utils.MetaWeight, + Routes: []*Route{{ + ID: "route1", + Weight: 10, + }, { + ID: "route2", + Weight: 20, + }}, + Weight: 20, + } + dm.SetRouteProfile(rpp, true) + + args := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "RouteProcessEvent", + Event: map[string]interface{}{ + utils.RequestType: utils.MetaPostpaid, + utils.Category: utils.Call, + utils.AccountField: "1003", + utils.Subject: "1003", + utils.Destination: "1002", + utils.AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC), + utils.SetupTime: time.Date(2018, 8, 24, 16, 00, 00, 0, time.UTC), + utils.Usage: time.Minute, + }, + } + + if err := rpS.V1GetRouteProfilesForEvent(args, &reply); err != nil { + t.Error(err) + } + + if !reflect.DeepEqual(reply[0], rpp) { + t.Errorf("expected %+v,received %+v", utils.ToJSON(rpp), utils.ToJSON(reply)) + } + +}