Add tests for filter validation functions

apis/filters_it_test.go

@@ -63,6 +63,7 @@ var (
 		testFilterSGetFilters3,
 		testFilterSSetGetFilterWithPrefix,
 		testFilterSGetFiltersWithPrefix,
+		testFilterSSetInvalidFilter,
 		testFilterSKillEngine,
 	}
 )
@@ -682,6 +683,37 @@ func testFilterSGetFiltersWithPrefix(t *testing.T) {
 	}
 }
 
+func testFilterSSetInvalidFilter(t *testing.T) {
+	fltrPrf := &engine.FilterWithAPIOpts{
+		Filter: &engine.Filter{
+			Tenant: utils.CGRateSorg,
+			ID:     "invalid_filter",
+			Rules: []*engine.FilterRule{
+				{
+					Type:    utils.MetaString,
+					Element: "",
+					Values:  []string{},
+				},
+			},
+		},
+	}
+	experr := `SERVER_ERROR: there exists at least one filter rule that is not valid`
+	var reply string
+	if err := fltrSRPC.Call(context.Background(), utils.AdminSv1SetFilter,
+		fltrPrf, &reply); err == nil || err.Error() != experr {
+		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
+	}
+
+	var result *engine.Filter
+	if err := fltrSRPC.Call(context.Background(), utils.AdminSv1GetFilter,
+		&utils.TenantID{
+			Tenant: utils.CGRateSorg,
+			ID:     "invalid_filter",
+		}, &result); err == nil || err.Error() != utils.ErrNotFound.Error() {
+		t.Errorf("expected: <%+v>, \nreceived: <%+v>", utils.ErrNotFound, err)
+	}
+}
+
 //Kill the engine when it is about to be finished
 func testFilterSKillEngine(t *testing.T) {
 	if err := engine.KillEngine(100); err != nil {

apis/filters_test.go

@@ -1241,5 +1241,54 @@ func TestFiltersGetFilterIDs(t *testing.T) {
 	if err == nil || err.Error() != "NOT_IMPLEMENTED" {
 		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "NOT_IMPLEMENTED", err)
 	}
-
+}
+
+func TestFiltersValidateFilterRuleOK(t *testing.T) {
+	fltrRules := []*engine.FilterRule{
+		{
+			Type:    utils.MetaString,
+			Element: "~*req.Subject",
+			Values:  []string{"1004", "6774", "22312"},
+		},
+		{
+			Type:    utils.MetaString,
+			Element: "~*opts.Subsystems",
+			Values:  []string{"*attributes"},
+		},
+		{
+			Type:    utils.MetaPrefix,
+			Element: "~*req.Destinations",
+			Values:  []string{"+0775", "+442"},
+		},
+	}
+
+	if err := validateFilterRules(fltrRules); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestFiltersValidateFilterRuleErr(t *testing.T) {
+	fltrRules := []*engine.FilterRule{
+		{
+			Type:    utils.MetaString,
+			Element: "~*req.Subject",
+			Values:  []string{"1004", "6774", "22312"},
+		},
+		{
+			Type:    utils.MetaString,
+			Element: "~*opts.Subsystems",
+			Values:  []string{"*attributes"},
+		},
+		{
+			Type:    utils.MetaString,
+			Element: "",
+			Values:  []string{},
+		},
+	}
+
+	experr := `there exists at least one filter rule that is not valid`
+	if err := validateFilterRules(fltrRules); err == nil ||
+		err.Error() != experr {
+		t.Errorf("expected: <%+v>, \nreceived: <%+v>", experr, err)
+	}
 }

engine/filters_test.go

@@ -1487,3 +1487,509 @@ func TestFilterMerge(t *testing.T) {
 		t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(dp))
 	}
 }
+
+func TestFiltersFilterRuleIsValid(t *testing.T) {
+	fltr := &FilterRule{
+		Type:    utils.EmptyString,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNever,
+		Element: "",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaExists,
+		Element: "",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaExists,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaExists,
+		Element: "~*req.Element",
+		Values:  []string{"value1"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotExists,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaEmpty,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotEmpty,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaString,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotString,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaPrefix,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotPrefix,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaSuffix,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotSuffix,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaCronExp,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotCronExp,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaRSR,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotRSR,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaLessThan,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaLessOrEqual,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaGreaterThan,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaGreaterOrEqual,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaEqual,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotEqual,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaIPNet,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotIPNet,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaAPIBan,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotAPIBan,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaActivationInterval,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotActivationInterval,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaRegex,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotRegex,
+		Element: "~*req.Element",
+		Values:  []string{},
+	}
+	if isValid := fltr.IsValid(); isValid != false {
+		t.Error("filter should not be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaString,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotString,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaPrefix,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotPrefix,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaSuffix,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotSuffix,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaCronExp,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotCronExp,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaRSR,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotRSR,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaLessThan,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaLessOrEqual,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaGreaterThan,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaGreaterOrEqual,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaEqual,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotEqual,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaIPNet,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotIPNet,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaAPIBan,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotAPIBan,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaActivationInterval,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotActivationInterval,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaRegex,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+
+	fltr = &FilterRule{
+		Type:    utils.MetaNotRegex,
+		Element: "~*req.Element",
+		Values:  []string{"value1", "value2"},
+	}
+	if isValid := fltr.IsValid(); isValid != true {
+		t.Error("filter should be valid")
+	}
+}