fix(automations): negate regex match for NotContains/NotEqual operators (#1441)

Co-authored-by: soup <s0up4200@pm.me>

Author: andresatierf

documentation/docs/features/automations.md

@@ -132,7 +132,21 @@ The State field matches these status buckets:
 
 ### Regex Support
 
-Full RE2 (Go regex) syntax supported. Patterns are case-insensitive by default. The UI validates patterns and shows helpful error messages for invalid regex.
+Full RE2 (Go regex) syntax supported. Patterns are case-insensitive by default.
+
+Regex can be used either by selecting **matches regex** or by enabling the **Regex** toggle for a condition:
+
+- When regex is enabled, the condition checks whether the regex matches the field value.
+- `not equals` and `not contains` invert the regex result (true only if the regex does **not** match).
+- Operators like `equals`, `contains`, `starts with`, and `ends with` are treated as regex match when regex is enabled.
+- Regex is not implicitly anchored: use `^` and `$` if you want an exact/full-string match (example: `^BHD$`).
+
+Field notes:
+
+- **Tracker**: checked against multiple candidates (raw URL, extracted domain, and optional customization display name). Negative regex passes only if **none** of the candidates match.
+- **Tags**: without regex, string operators are applied per-tag. With regex enabled, the regex is matched against the full raw tags string.
+
+The UI validates patterns and shows helpful error messages for invalid regex.
 
 ## Tracker Matching
 

internal/services/automations/evaluator.go

@@ -573,7 +573,11 @@ func compareString(value string, cond *RuleCondition) bool {
 		if cond.Compiled == nil {
 			return false
 		}
-		return cond.Compiled.MatchString(value)
+		matched := cond.Compiled.MatchString(value)
+		if cond.Operator == OperatorNotContains || cond.Operator == OperatorNotEqual {
+			return !matched
+		}
+		return matched
 	}
 
 	switch cond.Operator {
@@ -621,15 +625,23 @@ func compareTracker(trackerURL string, cond *RuleCondition, ctx *EvalContext) bo
 		return compareString("", cond)
 	}
 
-	// Keep string-field semantics consistent: when regex is enabled, operator is ignored and we
-	// just test the regex against the value.
 	if cond.Regex || cond.Operator == OperatorMatches {
+		if cond.Compiled == nil {
+			return false
+		}
+		anyMatch := false
 		for _, c := range candidates {
-			if compareString(c, cond) {
-				return true
+			if cond.Compiled.MatchString(c) {
+				anyMatch = true
+				break
 			}
 		}
-		return false
+		if cond.Operator == OperatorNotContains || cond.Operator == OperatorNotEqual {
+			// Negative operators apply to the combined candidate set: fail if any candidate matches.
+			return !anyMatch
+		}
+		// Regex-enabled string operators: succeed if any candidate matches.
+		return anyMatch
 	}
 
 	// Important: negative operators must apply to the combined candidate set.
@@ -720,7 +732,11 @@ func compareTags(tagsRaw string, cond *RuleCondition) bool {
 		if cond.Compiled == nil {
 			return false
 		}
-		return cond.Compiled.MatchString(tagsRaw)
+		matched := cond.Compiled.MatchString(tagsRaw)
+		if cond.Operator == OperatorNotContains || cond.Operator == OperatorNotEqual {
+			return !matched
+		}
+		return matched
 	}
 
 	tags := splitTags(tagsRaw)

internal/services/automations/evaluator_test.go

@@ -217,6 +217,72 @@ func TestEvaluateCondition_StringFields(t *testing.T) {
 			torrent:  qbt.Torrent{Name: "Test.Torrent.2024"},
 			expected: true,
 		},
+		{
+			name: "not_contains regex - false when regex matches",
+			cond: &RuleCondition{
+				Field:    FieldName,
+				Operator: OperatorNotContains,
+				Value:    "^Test.*2024$",
+				Regex:    true,
+			},
+			torrent:  qbt.Torrent{Name: "Test.Torrent.2024"},
+			expected: false,
+		},
+		{
+			name: "not_contains regex - true when regex does not match",
+			cond: &RuleCondition{
+				Field:    FieldName,
+				Operator: OperatorNotContains,
+				Value:    "^Movie.*2024$",
+				Regex:    true,
+			},
+			torrent:  qbt.Torrent{Name: "Test.Torrent.2024"},
+			expected: true,
+		},
+		{
+			name: "not_equal regex - false when regex matches",
+			cond: &RuleCondition{
+				Field:    FieldName,
+				Operator: OperatorNotEqual,
+				Value:    ".*Torrent.*",
+				Regex:    true,
+			},
+			torrent:  qbt.Torrent{Name: "Test.Torrent.2024"},
+			expected: false,
+		},
+		{
+			name: "not_equal regex - true when regex does not match",
+			cond: &RuleCondition{
+				Field:    FieldName,
+				Operator: OperatorNotEqual,
+				Value:    "^Movie",
+				Regex:    true,
+			},
+			torrent:  qbt.Torrent{Name: "Test.Torrent.2024"},
+			expected: true,
+		},
+		{
+			name: "contains regex - true when regex matches",
+			cond: &RuleCondition{
+				Field:    FieldName,
+				Operator: OperatorContains,
+				Value:    "Torrent",
+				Regex:    true,
+			},
+			torrent:  qbt.Torrent{Name: "Test.Torrent.2024"},
+			expected: true,
+		},
+		{
+			name: "contains regex - false when regex does not match",
+			cond: &RuleCondition{
+				Field:    FieldName,
+				Operator: OperatorContains,
+				Value:    "^Movie",
+				Regex:    true,
+			},
+			torrent:  qbt.Torrent{Name: "Test.Torrent.2024"},
+			expected: false,
+		},
 	}
 
 	for _, tt := range tests {
@@ -280,6 +346,54 @@ func TestEvaluateCondition_TrackerField_DisplayNameAndNegation(t *testing.T) {
 			t.Fatalf("expected false, got %v", got)
 		}
 	})
+
+	t.Run("not_equal regex - false when any candidate matches (display name)", func(t *testing.T) {
+		cond := &RuleCondition{
+			Field:    FieldTracker,
+			Operator: OperatorNotEqual,
+			Value:    "^BHD$",
+			Regex:    true,
+		}
+		if got := EvaluateConditionWithContext(cond, torrent, ctx, 0); got != false {
+			t.Fatalf("expected false, got %v", got)
+		}
+	})
+
+	t.Run("not_contains regex - false when any candidate matches (display name)", func(t *testing.T) {
+		cond := &RuleCondition{
+			Field:    FieldTracker,
+			Operator: OperatorNotContains,
+			Value:    "BHD",
+			Regex:    true,
+		}
+		if got := EvaluateConditionWithContext(cond, torrent, ctx, 0); got != false {
+			t.Fatalf("expected false, got %v", got)
+		}
+	})
+
+	t.Run("not_equal regex - true when no candidate matches", func(t *testing.T) {
+		cond := &RuleCondition{
+			Field:    FieldTracker,
+			Operator: OperatorNotEqual,
+			Value:    "^XYZ$",
+			Regex:    true,
+		}
+		if got := EvaluateConditionWithContext(cond, torrent, ctx, 0); got != true {
+			t.Fatalf("expected true, got %v", got)
+		}
+	})
+
+	t.Run("not_contains regex - true when no candidate matches", func(t *testing.T) {
+		cond := &RuleCondition{
+			Field:    FieldTracker,
+			Operator: OperatorNotContains,
+			Value:    "XYZ",
+			Regex:    true,
+		}
+		if got := EvaluateConditionWithContext(cond, torrent, ctx, 0); got != true {
+			t.Fatalf("expected true, got %v", got)
+		}
+	})
 }
 
 func TestEvaluateCondition_NumericFields(t *testing.T) {