Implementing @bors info command

Rhythm1710 · Rhythm1710 · commit a7abd052ccfb · 2025-03-11T14:47:22.000+05:30
diff --git a/.gitignore b/.gitignore
@@ -1 +1,2 @@
 target/
+.env
diff --git a/.sqlx/query-2eaf959d9345ee1d1baf5453b693f0914014029977243d15ef233e8fba49f2d5.json b/.sqlx/query-2eaf959d9345ee1d1baf5453b693f0914014029977243d15ef233e8fba49f2d5.json
diff --git a/src/bors/command/mod.rs b/src/bors/command/mod.rs
@@ -49,6 +49,8 @@ pub enum BorsCommand {
     TryCancel,
     /// Set the priority of a commit.
     SetPriority(Priority),
+    /// Get information about the current PR.
+    Info,
     /// Delegate approval authority to the pull request author.
     Delegate,
     /// Revoke any previously granted delegation.
diff --git a/src/bors/command/parser.rs b/src/bors/command/parser.rs
@@ -51,6 +51,7 @@ impl CommandParser {
             parser_ping,
             parser_try_cancel,
             parser_try,
+            parser_info,
             parse_delegate_author,
             parse_undelegate,
         ];
@@ -132,7 +133,6 @@ fn parse_parts(input: &str) -> Result<Vec<CommandPart>, CommandParseError> {
 }
 
 /// Parsers
-
 /// Parses "@bors r+ <p=priority>"
 fn parse_self_approve<'a>(command: &'a str, parts: &[CommandPart<'a>]) -> ParseResult<'a> {
     if command != "r+" {
@@ -342,6 +342,15 @@ fn parse_priority_arg<'a>(parts: &[CommandPart<'a>]) -> Result<Option<u32>, Comm
     Ok(priority)
 }
 
+/// Parses "@bors info"
+fn parser_info<'a>(command: &'a str, _parts: &[CommandPart<'a>]) -> ParseResult<'a> {
+    if command == "info" {
+        Some(Ok(BorsCommand::Info))
+    } else {
+        None
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::bors::command::parser::{CommandParseError, CommandParser};
@@ -835,6 +844,20 @@ line two
         "###)
     }
 
+    #[test]
+    fn parse_info() {
+        let cmds = parse_commands("@bors info");
+        assert_eq!(cmds.len(), 1);
+        assert!(matches!(cmds[0], Ok(BorsCommand::Info)));
+    }
+
+    #[test]
+    fn parse_info_unknown_arg() {
+        let cmds = parse_commands("@bors info a");
+        assert_eq!(cmds.len(), 1);
+        assert!(matches!(cmds[0], Ok(BorsCommand::Info)));
+    }
+
     #[test]
     fn parse_try_cancel() {
         let cmds = parse_commands("@bors try cancel");
diff --git a/src/bors/handlers/help.rs b/src/bors/handlers/help.rs
@@ -28,6 +28,7 @@ pub(super) async fn command_help(
         BorsCommand::TryCancel,
         BorsCommand::Ping,
         BorsCommand::Help,
+        BorsCommand::Info,
     ]
     .into_iter()
     .map(|help| format!("- {}", get_command_help(help)))
@@ -73,6 +74,9 @@ fn get_command_help(command: BorsCommand) -> String {
         BorsCommand::TryCancel => {
             "`try cancel`: Cancel a running try build"
         }
+        BorsCommand::Info => {
+            "`info`: Get information about the current PR including delegation, priority, merge status, and try build status"
+        }
     };
     help.to_string()
 }
@@ -96,6 +100,7 @@ mod tests {
             - `try cancel`: Cancel a running try build
             - `ping`: Check if the bot is alive
             - `help`: Print this help message
+            - `info`: Get information about the current PR including delegation, priority, merge status, and try build status
             ");
             Ok(tester)
         })
diff --git a/src/bors/handlers/info.rs b/src/bors/handlers/info.rs
@@ -0,0 +1,181 @@
+use crate::bors::Comment;
+use crate::bors::RepositoryState;
+use crate::database::PgDbClient;
+use crate::github::PullRequest;
+use std::sync::Arc;
+
+pub(super) async fn command_info(
+    repo: Arc<RepositoryState>,
+    pr: &PullRequest,
+    db: Arc<PgDbClient>,
+) -> anyhow::Result<()> {
+    // Geting PR info from database
+    let pr_model = db
+        .get_or_create_pull_request(repo.client.repository(), pr.number)
+        .await?;
+
+    // Building the info message
+    let mut info_lines = Vec::new();
+
+    // Approval info
+    if let Some(approved_by) = pr_model.approved_by {
+        info_lines.push(format!("- **Approved by:** @{}", approved_by));
+    } else {
+        info_lines.push("- **Not Approved:**".to_string());
+    }
+
+    // Priority info
+    if let Some(priority) = pr_model.priority {
+        info_lines.push(format!("- **Priority:** {}", priority));
+    } else {
+        info_lines.push("- **Priority:** Not set".to_string());
+    }
+
+    // Build status
+    if let Some(try_build) = pr_model.try_build {
+        info_lines.push(format!("- **Try build branch:** {}", try_build.branch));
+
+        if let Ok(urls) = db.get_workflow_urls_for_build(&try_build).await {
+            info_lines.extend(
+                urls.into_iter()
+                    .map(|url| format!("- **Workflow URL:** {}", url)),
+            );
+        }
+    }
+
+    // Joining all lines
+    let info = info_lines.join("\n");
+
+    // Post the comment
+    repo.client
+        .post_comment(pr.number, Comment::new(info))
+        .await?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::mocks::{BorsBuilder, User, World};
+
+    fn create_world_with_approve_config() -> World {
+        let world = World::default();
+        world.default_repo().lock().set_config(
+            r#"
+[labels]
+approve = ["+approved"]
+"#,
+        );
+        world
+    }
+
+    #[sqlx::test]
+    async fn info_for_unapproved_pr(pool: sqlx::PgPool) {
+        BorsBuilder::new(pool)
+            .world(World::default())
+            .run_test(|mut tester| async {
+                tester.post_comment("@bors info").await?;
+                assert_eq!(
+                    tester.get_comment().await?,
+                    "- **Not Approved:**\n- **Priority:** Not set"
+                );
+                Ok(tester)
+            })
+            .await;
+    }
+
+    #[sqlx::test]
+    async fn info_for_approved_pr(pool: sqlx::PgPool) {
+        BorsBuilder::new(pool)
+            .world(create_world_with_approve_config())
+            .run_test(|mut tester| async {
+                // First approve the PR
+                tester.post_comment("@bors r+").await?;
+                tester.expect_comments(1).await;
+
+                // Then check info
+                tester.post_comment("@bors info").await?;
+                assert_eq!(
+                    tester.get_comment().await?,
+                    format!(
+                        "- **Approved by:** @{}\n- **Priority:** Not set",
+                        User::default_user().name
+                    )
+                );
+                Ok(tester)
+            })
+            .await;
+    }
+
+    #[sqlx::test]
+    async fn info_for_pr_with_priority(pool: sqlx::PgPool) {
+        BorsBuilder::new(pool)
+            .world(create_world_with_approve_config())
+            .run_test(|mut tester| async {
+                // Set priority
+                tester.post_comment("@bors p=5").await?;
+                tester
+                    .wait_for(|| async {
+                        let pr = tester.get_default_pr().await?;
+                        Ok(pr.priority == Some(5))
+                    })
+                    .await?;
+
+                // Check info
+                tester.post_comment("@bors info").await?;
+                assert_eq!(
+                    tester.get_comment().await?,
+                    "- **Not Approved:**\n- **Priority:** 5"
+                );
+                Ok(tester)
+            })
+            .await;
+    }
+
+    #[sqlx::test]
+    async fn info_for_pr_with_try_build(pool: sqlx::PgPool) {
+        BorsBuilder::new(pool)
+            .world(create_world_with_approve_config())
+            .run_test(|mut tester| async {
+                // Create a try build
+                tester.post_comment("@bors try").await?;
+                tester.expect_comments(1).await;
+
+                // Check info
+                tester.post_comment("@bors info").await?;
+                assert_eq!(
+                    tester.get_comment().await?,
+                    "- **Not Approved:**\n- **Priority:** Not set\n- **Try build branch:** automation/bors/try"
+                );
+                Ok(tester)
+            })
+            .await;
+    }
+
+    #[sqlx::test]
+    async fn info_for_pr_with_everything(pool: sqlx::PgPool) {
+        BorsBuilder::new(pool)
+            .world(create_world_with_approve_config())
+            .run_test(|mut tester| async {
+                // Approve with priority
+                tester.post_comment("@bors r+ p=10").await?;
+                tester.expect_comments(1).await;
+
+                // Create a try build
+                tester.post_comment("@bors try").await?;
+                tester.expect_comments(1).await;
+
+                // Check info
+                tester.post_comment("@bors info").await?;
+                assert_eq!(
+                    tester.get_comment().await?,
+                    format!(
+                        "- **Approved by:** @{}\n- **Priority:** 10\n- **Try build branch:** automation/bors/try",
+                        User::default_user().name
+                    )
+                );
+                Ok(tester)
+            })
+            .await;
+    }
+}
diff --git a/src/bors/handlers/mod.rs b/src/bors/handlers/mod.rs
@@ -8,6 +8,7 @@ use tracing::Instrument;
 use crate::bors::command::{BorsCommand, CommandParseError};
 use crate::bors::event::{BorsGlobalEvent, BorsRepositoryEvent, PullRequestComment};
 use crate::bors::handlers::help::command_help;
+use crate::bors::handlers::info::command_info;
 use crate::bors::handlers::ping::command_ping;
 use crate::bors::handlers::refresh::refresh_repository;
 use crate::bors::handlers::review::{
@@ -26,6 +27,7 @@ use crate::{load_repositories, PgDbClient, TeamApiClient};
 use crate::tests::util::TestSyncMarker;
 
 mod help;
+mod info;
 mod labels;
 mod ping;
 mod refresh;
@@ -278,6 +280,12 @@ async fn handle_comment(
                             .instrument(span)
                             .await
                     }
+                    BorsCommand::Info => {
+                        let span = tracing::info_span!("Info");
+                        command_info(repo, &pull_request, database)
+                            .instrument(span)
+                            .await
+                    }
                 };
                 if result.is_err() {
                     return result.context("Cannot execute Bors command");
diff --git a/src/database/client.rs b/src/database/client.rs
@@ -9,8 +9,8 @@ use crate::github::{CommitSha, GithubRepoName};
 use super::operations::{
     approve_pull_request, create_build, create_pull_request, create_workflow,
     delegate_pull_request, find_build, find_pr_by_build, get_pull_request, get_running_builds,
-    get_workflows_for_build, set_pr_priority, unapprove_pull_request, undelegate_pull_request,
-    update_build_status, update_pr_build_id, update_workflow_status,
+    get_workflow_urls_for_build, get_workflows_for_build, set_pr_priority, unapprove_pull_request,
+    undelegate_pull_request, update_build_status, update_pr_build_id, update_workflow_status,
 };
 use super::RunId;
 
@@ -186,4 +186,18 @@ impl PgDbClient {
             .collect::<Vec<_>>();
         Ok(workflows)
     }
+    pub async fn get_pull_request(
+        &self,
+        repo: &GithubRepoName,
+        pr_number: PullRequestNumber,
+    ) -> anyhow::Result<Option<PullRequestModel>> {
+        get_pull_request(&self.pool, repo, pr_number).await
+    }
+
+    pub async fn get_workflow_urls_for_build(
+        &self,
+        build: &BuildModel,
+    ) -> anyhow::Result<Vec<String>> {
+        get_workflow_urls_for_build(&self.pool, build.id).await
+    }
 }
diff --git a/src/database/operations.rs b/src/database/operations.rs
@@ -369,6 +369,24 @@ WHERE build.id = $1
     Ok(workflows)
 }
 
+pub(crate) async fn get_workflow_urls_for_build(
+    executor: impl PgExecutor<'_>,
+    build_id: i32,
+) -> anyhow::Result<Vec<String>> {
+    let results = sqlx::query!(
+        r#"
+SELECT url
+FROM workflow
+WHERE build_id = $1
+"#,
+        build_id
+    )
+    .fetch_optional(executor)
+    .await?;
+
+    Ok(results.into_iter().map(|r| r.url).collect())
+}
+
 #[cfg(test)]
 pub(crate) async fn get_all_workflows(
     executor: impl PgExecutor<'_>,
