From eda74a79a9180f25b95cfad4703f652b1c94b689 Mon Sep 17 00:00:00 2001 From: armirveliaj Date: Tue, 1 Jul 2025 10:52:26 -0400 Subject: [PATCH] Add coverage tests on FilterS --- engine/filters_test.go | 203 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 203 insertions(+) diff --git a/engine/filters_test.go b/engine/filters_test.go index 1293ffab2..e0ff2a56b 100644 --- a/engine/filters_test.go +++ b/engine/filters_test.go @@ -23,6 +23,7 @@ import ( "net/http" "net/http/httptest" "reflect" + "strings" "testing" "time" @@ -2723,3 +2724,205 @@ func TestFilterRanking(t *testing.T) { }) } } + +func TestGetFilters(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + data, _ := NewInternalDB(nil, nil, nil, cfg.DataDbCfg().Items) + dm := NewDataManager(data, cfg, nil) + + fltID := "fltTest" + tenant := "cgrates.org" + filter := &Filter{ + ID: fltID, + Tenant: tenant, + Rules: []*FilterRule{ + { + Type: "*string", + Element: "Account", + Values: []string{"1007"}, + }, + }, + } + + ctx := &context.Context{} + + err := dm.SetFilter(ctx, filter, true) + if err != nil { + t.Errorf("Failed to insert test filter: %v", err) + } + + filterIDs := []string{fltID} + result, err := GetFilters(ctx, filterIDs, tenant, dm) + if err != nil { + t.Errorf("GetFilters returned error: %v", err) + } + if len(result) != 1 { + t.Errorf("Expected 1 filter, got %d", len(result)) + } + if result[0].ID != fltID { + t.Errorf("Expected filter ID %s, got %s", fltID, result[0].ID) + } +} + +func TestCheckFilter(t *testing.T) { + validFilter := &Filter{ + Rules: []*FilterRule{ + { + Type: "*string", + Element: "validpath", + Values: []string{"val1"}, + }, + }, + } + + err := CheckFilter(validFilter) + if err != nil { + t.Errorf("Expected no error for valid filter, got: %v", err) + } + +} + +func TestFilterRulepassSentryPeer(t *testing.T) { + ctx := context.TODO() + + dp := utils.MapStorage{ + "IPAddr": "192.165.56.1", + } + + rsrParse := &utils.RSRParser{ + Path: "IPAddr", + } + if err := rsrParse.Compile(); err != nil { + t.Fatal("failed to compile RSRParser:", err) + } + + fltr := &FilterRule{ + rsrElement: rsrParse, + Values: []string{utils.MetaIP}, + } + + pass, err := fltr.passSentryPeer(ctx, dp) + if err != nil { + t.Errorf("Unexpected error: %v", err) + } + + fltr.Values = []string{"invalidValue"} + + pass, err = fltr.passSentryPeer(ctx, dp) + if err == nil { + t.Errorf("Expected error for invalid sentrypeer value, got nil") + } + if pass { + t.Errorf("Expected pass to be false on error") + } + + dpEmpty := utils.MapStorage{} + + fltr.Values = []string{utils.MetaNumber} + + pass, err = fltr.passSentryPeer(ctx, dpEmpty) + if err != nil { + t.Errorf("Unexpected error when data not found: %v", err) + } + +} + +func TestFilterClone(t *testing.T) { + orig := &Filter{ + Tenant: "cgrates.org", + ID: "flt123", + Rules: []*FilterRule{ + { + Type: utils.MetaString, + Element: "~*req.Account", + Values: []string{"1001", "1002"}, + }, + { + Type: utils.MetaNumber, + Element: "~*req.Duration", + Values: []string{"60"}, + }, + }, + } + + clone := orig.Clone() + + if clone == nil { + t.Fatal("Clone returned nil") + } + + if clone.Tenant != orig.Tenant { + t.Errorf("Tenant mismatch: got %s, want %s", clone.Tenant, orig.Tenant) + } + if clone.ID != orig.ID { + t.Errorf("ID mismatch: got %s, want %s", clone.ID, orig.ID) + } + + if &clone.Rules[0] == &orig.Rules[0] { + t.Error("Rules elements not cloned (same pointer)") + } + + if len(clone.Rules) != len(orig.Rules) { + t.Errorf("Rules length mismatch: got %d, want %d", len(clone.Rules), len(orig.Rules)) + } + + for i := range orig.Rules { + if clone.Rules[i].Type != orig.Rules[i].Type { + t.Errorf("Rule %d Type mismatch: got %s, want %s", i, clone.Rules[i].Type, orig.Rules[i].Type) + } + if clone.Rules[i].Element != orig.Rules[i].Element { + t.Errorf("Rule %d Element mismatch: got %s, want %s", i, clone.Rules[i].Element, orig.Rules[i].Element) + } + if len(clone.Rules[i].Values) != len(orig.Rules[i].Values) { + t.Errorf("Rule %d Values length mismatch: got %d, want %d", i, len(clone.Rules[i].Values), len(orig.Rules[i].Values)) + } + for j := range orig.Rules[i].Values { + if clone.Rules[i].Values[j] != orig.Rules[i].Values[j] { + t.Errorf("Rule %d Value %d mismatch: got %s, want %s", i, j, clone.Rules[i].Values[j], orig.Rules[i].Values[j]) + } + } + } + + var nilFilter *Filter + if nilFilter.Clone() != nil { + t.Error("Expected nil clone from nil Filter") + } +} + +func TestNewFilterRule(t *testing.T) { + rf, err := NewFilterRule(utils.MetaString, "~*req.Account", []string{"1001", "1002"}) + if err != nil { + t.Fatalf("Unexpected error for valid filter: %v", err) + } + if rf == nil { + t.Fatal("Expected non-nil FilterRule for valid input") + } + if rf.Type != utils.MetaString { + t.Errorf("Expected Type %s, got %s", utils.MetaString, rf.Type) + } + if rf.Element != "~*req.Account" { + t.Errorf("Expected Element '~*req.Account', got %s", rf.Element) + } + if rf.negative == nil || *rf.negative { + t.Errorf("Expected negative=false, got %v", rf.negative) + } + if len(rf.Values) != 2 { + t.Errorf("Expected 2 values, got %d", len(rf.Values)) + } + + _, err = NewFilterRule("unsupportedType", "field", []string{"val"}) + if err == nil || !strings.Contains(err.Error(), "Unsupported filter Type") { + t.Errorf("Expected unsupported type error, got %v", err) + } + + _, err = NewFilterRule(utils.MetaString, "", []string{"val"}) + if err == nil || !strings.Contains(err.Error(), "Element is mandatory") { + t.Errorf("Expected missing element error, got %v", err) + } + + _, err = NewFilterRule(utils.MetaString, "field", nil) + if err == nil || !strings.Contains(err.Error(), "Values is mandatory") { + t.Errorf("Expected missing values error, got %v", err) + } + +}