Move label matching logic to new module with tests

kailan · kailan · commit 97736f54effb · 2025-08-01T17:06:44.000+01:00
diff --git a/src/github.rs b/src/github.rs
@@ -1,25 +1,22 @@
+use crate::labels;
 use crate::team_data::TeamClient;
 use anyhow::{Context, anyhow};
 use async_trait::async_trait;
 use bytes::Bytes;
 use chrono::{DateTime, FixedOffset, Utc};
 use futures::{FutureExt, future::BoxFuture};
-use itertools::Itertools;
 use octocrab::models::{Author, AuthorAssociation};
 use regex::Regex;
 use reqwest::header::{AUTHORIZATION, USER_AGENT};
 use reqwest::{Client, Request, RequestBuilder, Response, StatusCode};
 use std::collections::{HashMap, HashSet};
-use std::sync::{LazyLock, OnceLock};
+use std::sync::OnceLock;
 use std::{
     fmt,
     time::{Duration, SystemTime},
 };
 use tracing as log;
 
-static EMOJI_REGEX: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"[\p{Emoji}\p{Emoji_Presentation}]").unwrap());
-
 pub type UserId = u64;
 pub type PullRequestNumber = u64;
 
@@ -578,40 +575,6 @@ impl IssueRepository {
     }
 }
 
-#[derive(Debug)]
-pub(crate) struct UnknownLabels {
-    labels: Vec<String>,
-}
-
-// NOTE: This is used to post the Github comment; make sure it's valid markdown.
-impl fmt::Display for UnknownLabels {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Unknown labels: {}", &self.labels.join(", "))
-    }
-}
-
-impl std::error::Error for UnknownLabels {}
-
-#[derive(Debug)]
-pub(crate) struct AmbiguousLabelMatch {
-    pub requested_label: String,
-    pub labels: Vec<String>,
-}
-
-// NOTE: This is used to post the Github comment; make sure it's valid markdown.
-impl fmt::Display for AmbiguousLabelMatch {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "Unsure which label to use for `{}` - could be one of: {}",
-            self.requested_label,
-            self.labels.iter().map(|l| format!("`{}`", l)).join(", ")
-        )
-    }
-}
-
-impl std::error::Error for AmbiguousLabelMatch {}
-
 impl Issue {
     pub fn to_zulip_github_reference(&self) -> ZulipGitHubReference {
         ZulipGitHubReference {
@@ -756,52 +719,13 @@ impl Issue {
             .await
             .context("unable to retrieve the repository labels")?;
 
-        let normalize = |s: &str| EMOJI_REGEX.replace_all(s, "").trim().to_lowercase();
-
-        let mut found_labels = Vec::with_capacity(requested_labels.len());
-        let mut unknown_labels = Vec::new();
-
-        for requested_label in requested_labels {
-            // First look for an exact match
-            if let Some(found) = available_labels.iter().find(|l| l.name == *requested_label) {
-                found_labels.push(found.name.clone());
-                continue;
-            }
-
-            // Try normalizing requested label (remove emoji, case insensitive, trim whitespace)
-            let normalized_requested: String = normalize(requested_label);
-
-            // Find matching labels by normalized name
-            let found = available_labels
+        labels::normalize_and_match_labels(
+            &available_labels
                 .iter()
-                .filter(|l| normalize(&l.name) == normalized_requested)
-                .collect::<Vec<_>>();
-
-            match found[..] {
-                [] => {
-                    unknown_labels.push(requested_label);
-                }
-                [label] => {
-                    found_labels.push(label.name.clone());
-                }
-                [..] => {
-                    return Err(AmbiguousLabelMatch {
-                        requested_label: requested_label.to_string(),
-                        labels: found.into_iter().map(|l| l.name.clone()).collect(),
-                    }
-                    .into());
-                }
-            };
-        }
-
-        if !unknown_labels.is_empty() {
-            return Err(UnknownLabels {
-                labels: unknown_labels.into_iter().map(|s| s.to_string()).collect(),
-            }
-            .into());
-        }
-
-        Ok(found_labels)
+                .map(|l| l.name.as_str())
+                .collect::<Vec<_>>(),
+            requested_labels,
+        )
     }
 
     pub async fn remove_label(&self, client: &GithubClient, label: &str) -> anyhow::Result<()> {
@@ -3295,16 +3219,3 @@ impl Submodule {
         client.repository(fullname).await
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn display_labels() {
-        let x = UnknownLabels {
-            labels: vec!["A-bootstrap".into(), "xxx".into()],
-        };
-        assert_eq!(x.to_string(), "Unknown labels: A-bootstrap, xxx");
-    }
-}
diff --git a/src/handlers/assign.rs b/src/handlers/assign.rs
@@ -24,6 +24,7 @@ use crate::db::issue_data::IssueData;
 use crate::db::review_prefs::{RotationMode, get_review_prefs_batch};
 use crate::github::UserId;
 use crate::handlers::pr_tracking::ReviewerWorkqueue;
+use crate::labels;
 use crate::{
     config::AssignConfig,
     github::{self, Event, FileDiff, Issue, IssuesAction, Selection},
@@ -563,7 +564,7 @@ pub(super) async fn handle_command(
                         .add_labels(&ctx.github, vec![github::Label { name: t_label }])
                         .await
                     {
-                        if let Some(github::UnknownLabels { .. }) = err.downcast_ref() {
+                        if let Some(labels::UnknownLabels { .. }) = err.downcast_ref() {
                             log::warn!("Error assigning label: {}", err);
                         } else {
                             return Err(err);
diff --git a/src/handlers/autolabel.rs b/src/handlers/autolabel.rs
@@ -209,7 +209,7 @@ pub(super) async fn handle_input(
     match event.issue.add_labels(&ctx.github, input.add).await {
         Ok(()) => {}
         Err(e) => {
-            use crate::github::UnknownLabels;
+            use crate::labels::UnknownLabels;
             if let Some(err @ UnknownLabels { .. }) = e.downcast_ref() {
                 event
                     .issue
diff --git a/src/handlers/relabel.rs b/src/handlers/relabel.rs
@@ -11,10 +11,10 @@
 use crate::team_data::TeamClient;
 use crate::{
     config::RelabelConfig,
-    github::UnknownLabels,
     github::{self, Event},
     handlers::Context,
     interactions::ErrorComment,
+    labels::UnknownLabels,
 };
 use parser::command::relabel::{LabelDelta, RelabelCommand};
 
diff --git a/src/labels.rs b/src/labels.rs
@@ -0,0 +1,162 @@
+use std::{fmt, sync::LazyLock};
+
+use itertools::Itertools;
+use regex::Regex;
+
+static EMOJI_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"[\p{Emoji}\p{Emoji_Presentation}]").unwrap());
+
+pub(crate) fn normalize_and_match_labels(
+    available_labels: &[&str],
+    requested_labels: &[&str],
+) -> anyhow::Result<Vec<String>> {
+    let normalize = |s: &str| EMOJI_REGEX.replace_all(s, "").trim().to_lowercase();
+
+    let mut found_labels = Vec::<String>::with_capacity(requested_labels.len());
+    let mut unknown_labels = Vec::new();
+
+    for requested_label in requested_labels {
+        // First look for an exact match
+        if let Some(found) = available_labels.iter().find(|l| **l == *requested_label) {
+            found_labels.push((*found).into());
+            continue;
+        }
+
+        // Try normalizing requested label (remove emoji, case insensitive, trim whitespace)
+        let normalized_requested: String = normalize(requested_label);
+
+        // Find matching labels by normalized name
+        let found = available_labels
+            .iter()
+            .filter(|l| normalize(l) == normalized_requested)
+            .collect::<Vec<_>>();
+
+        match found[..] {
+            [] => {
+                unknown_labels.push(requested_label);
+            }
+            [label] => {
+                found_labels.push((*label).into());
+            }
+            [..] => {
+                return Err(AmbiguousLabelMatch {
+                    requested_label: requested_label.to_string(),
+                    labels: found.into_iter().map(|l| (*l).into()).collect(),
+                }
+                .into());
+            }
+        };
+    }
+
+    if !unknown_labels.is_empty() {
+        return Err(UnknownLabels {
+            labels: unknown_labels.iter().map(|s| s.to_string()).collect(),
+        }
+        .into());
+    }
+
+    Ok(found_labels)
+}
+
+#[derive(Debug)]
+pub(crate) struct UnknownLabels {
+    labels: Vec<String>,
+}
+
+// NOTE: This is used to post the Github comment; make sure it's valid markdown.
+impl fmt::Display for UnknownLabels {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Unknown labels: {}", &self.labels.join(", "))
+    }
+}
+
+impl std::error::Error for UnknownLabels {}
+
+#[derive(Debug)]
+pub(crate) struct AmbiguousLabelMatch {
+    pub requested_label: String,
+    pub labels: Vec<String>,
+}
+
+// NOTE: This is used to post the Github comment; make sure it's valid markdown.
+impl fmt::Display for AmbiguousLabelMatch {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Unsure which label to use for `{}` - could be one of: {}",
+            self.requested_label,
+            self.labels.iter().map(|l| format!("`{}`", l)).join(", ")
+        )
+    }
+}
+
+impl std::error::Error for AmbiguousLabelMatch {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn display_unknown_labels_error() {
+        let x = UnknownLabels {
+            labels: vec!["A-bootstrap".into(), "xxx".into()],
+        };
+        assert_eq!(x.to_string(), "Unknown labels: A-bootstrap, xxx");
+    }
+
+    #[test]
+    fn display_ambiguous_label_error() {
+        let x = AmbiguousLabelMatch {
+            requested_label: "A-bootstrap".into(),
+            labels: vec!["A-bootstrap".into(), "A-bootstrap-2".into()],
+        };
+        assert_eq!(
+            x.to_string(),
+            "Unsure which label to use for `A-bootstrap` - could be one of: `A-bootstrap`, `A-bootstrap-2`"
+        );
+    }
+
+    #[test]
+    fn normalize_and_match_labels_happy_path() {
+        let available_labels = vec!["A-bootstrap 😺", "B-foo 👾", "C-bar", "C-bar 😦"];
+        let requested_labels = vec!["A-bootstrap", "B-foo", "C-bar"];
+
+        let result = normalize_and_match_labels(&available_labels, &requested_labels);
+
+        assert!(result.is_ok());
+        let found_labels = result.unwrap();
+        assert_eq!(found_labels.len(), 3);
+        assert_eq!(found_labels[0], "A-bootstrap 😺");
+        assert_eq!(found_labels[1], "B-foo 👾");
+        assert_eq!(found_labels[2], "C-bar");
+    }
+
+    #[test]
+    fn normalize_and_match_labels_no_match() {
+        let available_labels = vec!["A-bootstrap", "B-foo"];
+        let requested_labels = vec!["A-bootstrap", "C-bar"];
+
+        let result = normalize_and_match_labels(&available_labels, &requested_labels);
+
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(err.is::<UnknownLabels>());
+        let unknown = err.downcast::<UnknownLabels>().unwrap();
+        assert_eq!(unknown.labels, vec!["C-bar"]);
+    }
+
+    #[test]
+    fn normalize_and_match_labels_ambiguous_match() {
+        let available_labels = vec!["A-bootstrap 😺", "A-bootstrap 👾"];
+        let requested_labels = vec!["A-bootstrap"];
+
+        let result = normalize_and_match_labels(&available_labels, &requested_labels);
+
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(err.is::<AmbiguousLabelMatch>());
+        let ambiguous = err.downcast::<AmbiguousLabelMatch>().unwrap();
+        assert_eq!(ambiguous.requested_label, "A-bootstrap");
+        assert_eq!(ambiguous.labels, vec!["A-bootstrap 😺", "A-bootstrap 👾"]);
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -18,6 +18,7 @@ pub mod github;
 pub mod handlers;
 mod interactions;
 pub mod jobs;
+pub mod labels;
 pub mod notification_listing;
 pub mod payload;
 mod rfcbot;
