Add coverage tests on engine

ees/sql_test.go

@@ -159,3 +159,15 @@ func TestPrepareMap(t *testing.T) {
 		t.Errorf("PrepareMap() returned a non-nil result: %v", result)
 	}
 }
+
+func TestExportEvent(t *testing.T) {
+	sqlEe := &SQLEe{
+		db:   nil,
+		reqs: &concReq{},
+	}
+	err := sqlEe.ExportEvent(&sqlPosterRequest{}, "")
+	if err != utils.ErrDisconnected {
+		t.Errorf("Expected error %v, got %v", utils.ErrDisconnected, err)
+	}
+
+}

engine/filters_test.go

@@ -3005,3 +3005,113 @@ func TestFilterRuleElementItems(t *testing.T) {
 		t.Errorf("Expected: %v , received: %v", exp, rcv)
 	}
 }
+
+func TestNewFilterRule(t *testing.T) {
+	t.Run("Valid filter rule", func(t *testing.T) {
+		rfType := "*regex"
+		fieldName := "field"
+		vals := []string{"val1", "val2"}
+
+		rule, err := NewFilterRule(rfType, fieldName, vals)
+
+		if err != nil {
+			t.Errorf("Expected no error, got %v", err)
+		}
+		if rule == nil {
+			t.Fatalf("Expected a valid FilterRule, got nil")
+		}
+		if rule.Type != rfType {
+			t.Errorf("Expected Type to be %v, got %v", rfType, rule.Type)
+		}
+		if rule.Element != fieldName {
+			t.Errorf("Expected Element to be %v, got %v", fieldName, rule.Element)
+		}
+		if len(rule.Values) != len(vals) || rule.Values[0] != vals[0] || rule.Values[1] != vals[1] {
+			t.Errorf("Expected Values to be %v, got %v", vals, rule.Values)
+		}
+		if rule.negative == nil || *rule.negative {
+			t.Errorf("Expected negative to be false, got %v", rule.negative)
+		}
+	})
+
+	t.Run("Unsupported filter type", func(t *testing.T) {
+		rfType := "*unsupported"
+		fieldName := "field"
+		vals := []string{"val1"}
+
+		rule, err := NewFilterRule(rfType, fieldName, vals)
+
+		if err == nil || err.Error() != "Unsupported filter Type: *unsupported" {
+			t.Errorf("Expected error 'Unsupported filter Type: *unsupported', got %v", err)
+		}
+		if rule != nil {
+			t.Errorf("Expected nil FilterRule, got %v", rule)
+		}
+	})
+
+	t.Run("Missing field name for type requiring it", func(t *testing.T) {
+		rfType := "*regex"
+		fieldName := ""
+		vals := []string{"val1"}
+
+		rule, err := NewFilterRule(rfType, fieldName, vals)
+
+		if err == nil || err.Error() != "Element is mandatory for Type: *regex" {
+			t.Errorf("Expected error 'Element is mandatory for Type: *regex', got %v", err)
+		}
+		if rule != nil {
+			t.Errorf("Expected nil FilterRule, got %v", rule)
+		}
+	})
+
+	t.Run("Missing values for type requiring them", func(t *testing.T) {
+		rfType := "*regex"
+		fieldName := "field"
+		vals := []string{}
+
+		rule, err := NewFilterRule(rfType, fieldName, vals)
+
+		if err == nil || err.Error() != "Values is mandatory for Type: *regex" {
+			t.Errorf("Expected error 'Values is mandatory for Type: *regex', got %v", err)
+		}
+		if rule != nil {
+			t.Errorf("Expected nil FilterRule, got %v", rule)
+		}
+	})
+
+	t.Run("MetaHTTP prefix handling", func(t *testing.T) {
+		rfType := "*http/specific"
+		fieldName := "url"
+		vals := []string{"http://cgrates.com"}
+
+		rule, err := NewFilterRule(rfType, fieldName, vals)
+
+		if err != nil {
+			t.Errorf("Expected no error, got %v", err)
+		}
+		if rule == nil {
+			t.Fatalf("Expected a valid FilterRule, got nil")
+		}
+		if rule.Element != fieldName {
+			t.Errorf("Expected Element to be %v, got %v", fieldName, rule.Element)
+		}
+		if len(rule.Values) != len(vals) || rule.Values[0] != vals[0] {
+			t.Errorf("Expected Values to be %v, got %v", vals, rule.Values)
+		}
+	})
+
+	t.Run("CompileValues error handling", func(t *testing.T) {
+		rfType := "*regex"
+		fieldName := "pattern"
+		vals := []string{"[invalid-regex"}
+
+		rule, err := NewFilterRule(rfType, fieldName, vals)
+
+		if err == nil || !strings.Contains(err.Error(), "error parsing regexp") {
+			t.Errorf("Expected error parsing regexp, got %v", err)
+		}
+		if rule != nil {
+			t.Errorf("Expected nil FilterRule, got %v", rule)
+		}
+	})
+}

engine/libeventcost_test.go

@@ -1638,3 +1638,74 @@ func TestBalanceChargesClone(t *testing.T) {
 		}
 	})
 }
+
+func TestFieldsAsInterfaces(t *testing.T) {
+	ct := &ChargedTiming{
+		Years:     utils.Years{1, 2},
+		Months:    utils.Months{2, 3},
+		MonthDays: utils.MonthDays{4, 5},
+		WeekDays:  utils.WeekDays{2, 3},
+		StartTime: "Time",
+	}
+	tests := []struct {
+		name      string
+		fldPath   []string
+		expected  any
+		expectErr bool
+	}{
+		{
+			name:      "Years Field",
+			fldPath:   []string{utils.YearsFieldName},
+			expected:  ct.Years,
+			expectErr: false,
+		},
+		{
+			name:      "Months Field",
+			fldPath:   []string{utils.MonthsFieldName},
+			expected:  ct.Months,
+			expectErr: false,
+		},
+		{
+			name:      "MonthDays Field",
+			fldPath:   []string{utils.MonthDaysFieldName},
+			expected:  ct.MonthDays,
+			expectErr: false,
+		},
+		{
+			name:      "WeekDays Field",
+			fldPath:   []string{utils.WeekDaysFieldName},
+			expected:  ct.WeekDays,
+			expectErr: false,
+		},
+		{
+			name:      "StartTime Field",
+			fldPath:   []string{utils.StartTime},
+			expected:  ct.StartTime,
+			expectErr: false,
+		},
+		{
+			name:      "Invalid Field",
+			fldPath:   []string{"invalidField"},
+			expected:  nil,
+			expectErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			val, err := ct.FieldAsInterface(tt.fldPath)
+			if tt.expectErr {
+				if err == nil {
+					t.Errorf("Expected error, got nil")
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Expected no error, got %v", err)
+				}
+				if !reflect.DeepEqual(val, tt.expected) {
+					t.Errorf("Expected value %v, got %v", tt.expected, val)
+				}
+			}
+		})
+	}
+}