chore: third time's the charm

Author: Tofel

grafana-alertcheck/internal/gate/resolve.go

@@ -95,35 +95,39 @@ func resolveOne(defs []Definition, name, folder string) (Definition, error) {
 		return Definition{}, fmt.Errorf("no rule matched %q: no rule has this uid (run 'grafana-alertcheck list' to see uids)", name)
 	}
 
-	// A datasource rule's name can contain "/", so the full input may be a title,
-	// not a segmented form: try an exact title match before splitting.
-	if def, found, err := pickCandidate(defs, name, func(d Definition) bool {
-		return titleMatches(d, name, folder)
-	}); found {
-		return def, err
-	}
-
-	parts, err := parseNameForm(name)
-	if err != nil {
-		return Definition{}, err
+	// Two interpretations are possible: the whole input as one rule's exact
+	// title (a datasource rule's name can itself contain "/"), and the
+	// /-separated forms. Collect candidates from BOTH — a selector that is
+	// ambiguous between them must be reported, never silently resolved to one.
+	parts, formErr := parseNameForm(name)
+	var candidates []Definition
+	seen := make(map[string]bool, len(defs))
+	for _, d := range defs {
+		exact := titleMatches(d, name, folder)
+		segmented := formErr == nil && matchesName(d, parts, folder)
+		if !exact && !segmented {
+			continue
+		}
+		if key := defKey(d); !seen[key] {
+			seen[key] = true
+			candidates = append(candidates, d)
+		}
 	}
-	if def, found, err := pickCandidate(defs, name, func(d Definition) bool {
-		return matchesName(d, parts, folder)
-	}); found {
+	if def, found, err := pickCandidate(candidates, name); found {
 		return def, err
 	}
+	if formErr != nil {
+		return Definition{}, formErr
+	}
 	return Definition{}, noMatchError(supportedDefs(defs), name, parts[len(parts)-1])
 }
 
-// pickCandidate applies the shared one-match/ambiguous/unsupported/no-match
-// policy to a candidate predicate. found is false when nothing matched, so the
-// caller can try the next interpretation.
-func pickCandidate(defs []Definition, name string, match func(Definition) bool) (Definition, bool, error) {
+// pickCandidate applies the shared one-match/ambiguous/unsupported policy to the
+// collected candidates. found is false when nothing matched, so the caller can
+// fall through to the no-match surface.
+func pickCandidate(candidates []Definition, name string) (Definition, bool, error) {
 	var supported, unsupported []Definition
-	for _, d := range defs {
-		if !match(d) {
-			continue
-		}
+	for _, d := range candidates {
 		if isSupported(d) {
 			supported = append(supported, d)
 		} else {

grafana-alertcheck/internal/gate/resolve_test.go

@@ -243,6 +243,21 @@ func TestResolve_DatasourceNameWithSlashes(t *testing.T) {
 	require.Equal(t, name, resolved[0].Title)
 }
 
+// The same string can be one datasource rule's exact title AND a Grafana
+// Folder/Title selector. That must be reported as ambiguous, not silently
+// resolved to whichever interpretation is tried first.
+func TestResolve_ExactTitleVsSegmentedIsAmbiguous(t *testing.T) {
+	ds := Definition{
+		Key:   ruleKey("vm", "G", "Platform/HighErrorRate", "f", ""),
+		Title: "Platform/HighErrorRate", Group: "G",
+		Kind: KindDatasourceManaged, DatasourceUID: "vm", DatasourceName: "VM",
+	}
+	grafana := Definition{Key: "u1", UID: "u1", Title: "HighErrorRate", Folder: "Platform", Kind: KindGrafanaManaged}
+	_, _, err := Resolve([]Definition{grafana, ds}, []string{"Platform/HighErrorRate"}, "")
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "matches 2 rules")
+}
+
 // A key shared by two distinct rules cannot select one of them.
 func TestResolve_KeySharedByDistinctRulesIsAmbiguous(t *testing.T) {
 	a := Definition{