Deal with auto build success

- Post comment
- Update check run
- Modify labels

Author: Sakib25800

rust-bors.example.toml

@@ -19,3 +19,5 @@ approve = ["+approved"]
 try = ["+foo", "-bar"]
 try_succeed = ["+foobar", "+foo", "+baz"]
 try_failed = []
+succeeded = ["+foo", "+bar"]
+failed = ["+foo", "+bar"]

src/bors/comment.rs

@@ -192,3 +192,20 @@ pub fn auto_build_started_comment(head_sha: &CommitSha, merge_sha: &CommitSha) -
         head_sha, merge_sha
     ))
 }
+
+pub fn auto_build_succeeded_comment(
+    workflows: &[WorkflowModel],
+    approved_by: &str,
+    merge_sha: &CommitSha,
+    base_ref: &str,
+) -> Comment {
+    let urls = workflows
+        .iter()
+        .map(|w| format!("[{}]({})", w.name, w.url))
+        .collect::<Vec<_>>()
+        .join(", ");
+
+    Comment::new(format!(
+        ":sunny: Test successful - {urls}\nApproved by: `{approved_by}`\nPushing {merge_sha} to `{base_ref}`...",
+    ))
+}

src/bors/handlers/workflow.rs

@@ -9,6 +9,7 @@ use crate::bors::CheckSuiteStatus;
 use crate::bors::RepositoryState;
 use crate::bors::comment::{try_build_succeeded_comment, workflow_failed_comment};
 use crate::bors::event::{CheckSuiteCompleted, WorkflowCompleted, WorkflowStarted};
+use crate::bors::handlers::TRY_BRANCH_NAME;
 use crate::bors::handlers::is_bors_observed_branch;
 use crate::bors::handlers::labels::handle_label_trigger;
 use crate::bors::merge_queue::AUTO_BRANCH_NAME;
@@ -176,6 +177,7 @@ async fn try_complete_build(
     let has_failure = checks
         .iter()
         .any(|check| matches!(check.status, CheckSuiteStatus::Failure));
+    let build_succeeded = !has_failure;
 
     let mut workflows = db.get_workflows_for_build(&build).await?;
     workflows.sort_by(|a, b| a.name.cmp(&b.name));
@@ -192,42 +194,78 @@ async fn try_complete_build(
         return Ok(());
     }
 
-    let (status, trigger) = if has_failure {
-        (BuildStatus::Failure, LabelTrigger::TryBuildFailed)
+    let pr_num = pr.number;
+
+    if build_succeeded {
+        tracing::info!("Build succeeded for PR {pr_num}");
     } else {
-        (BuildStatus::Success, LabelTrigger::TryBuildSucceeded)
+        tracing::info!("Build failed for PR {pr_num}");
+    }
+
+    let branch = payload.branch.as_str();
+    let (status, trigger, comment_opt) = match (branch, build_succeeded) {
+        (TRY_BRANCH_NAME, true) => (
+            BuildStatus::Success,
+            LabelTrigger::TryBuildSucceeded,
+            Some(try_build_succeeded_comment(
+                &workflows,
+                payload.commit_sha.clone(),
+                &build,
+            )),
+        ),
+        (TRY_BRANCH_NAME, false) => (
+            BuildStatus::Failure,
+            LabelTrigger::TryBuildFailed,
+            Some(workflow_failed_comment(&workflows)),
+        ),
+        (AUTO_BRANCH_NAME, true) => (BuildStatus::Success, LabelTrigger::Succeeded, None),
+        (AUTO_BRANCH_NAME, false) => (
+            BuildStatus::Failure,
+            LabelTrigger::Failed,
+            Some(workflow_failed_comment(&workflows)),
+        ),
+        _ => unreachable!("Branch should be bors observed branch"),
     };
+
     db.update_build_status(&build, status).await?;
+    handle_label_trigger(repo, pr_num, trigger).await?;
 
-    handle_label_trigger(repo, pr.number, trigger).await?;
+    if let Some(comment) = comment_opt {
+        repo.client.post_comment(pr_num, comment).await?;
+    }
 
     if let Some(check_run_id) = build.check_run_id {
-        let (status, conclusion) = if has_failure {
-            (CheckRunStatus::Completed, Some(CheckRunConclusion::Failure))
+        tracing::info!(
+            "Updating check run {check_run_id} for build {} on {branch}",
+            build.commit_sha,
+        );
+        let conclusion = if build_succeeded {
+            Some(CheckRunConclusion::Success)
         } else {
-            (CheckRunStatus::Completed, Some(CheckRunConclusion::Success))
+            Some(CheckRunConclusion::Failure)
         };
 
         if let Err(error) = repo
             .client
-            .update_check_run(check_run_id as u64, status, conclusion, None)
+            .update_check_run(
+                check_run_id as u64,
+                CheckRunStatus::Completed,
+                conclusion,
+                None,
+            )
             .await
         {
             tracing::error!("Could not update check run {check_run_id}: {error:?}");
         }
-    }
-
-    let message = if !has_failure {
-        tracing::info!("Workflow succeeded");
-        try_build_succeeded_comment(&workflows, payload.commit_sha, &build)
     } else {
-        tracing::info!("Workflow failed");
-        workflow_failed_comment(&workflows)
-    };
-    repo.client.post_comment(pr.number, message).await?;
+        tracing::warn!(
+            "No check_run_id found for build {} on {branch}",
+            build.commit_sha,
+        );
+    }
 
     // Trigger merge queue when an auto build completes
-    if payload.branch == AUTO_BRANCH_NAME {
+    if branch == AUTO_BRANCH_NAME {
         merge_queue_tx.trigger().await?;
     }
 
@@ -236,8 +274,10 @@ async fn try_complete_build(
 
 #[cfg(test)]
 mod tests {
+    use octocrab::params::checks::{CheckRunConclusion, CheckRunStatus};
+
     use crate::bors::handlers::trybuild::TRY_BRANCH_NAME;
-    use crate::bors::merge_queue::{AUTO_BUILD_CHECK_RUN_NAME, AUTO_BRANCH_NAME};
+    use crate::bors::merge_queue::{AUTO_BRANCH_NAME, AUTO_BUILD_CHECK_RUN_NAME};
     use crate::database::WorkflowStatus;
     use crate::database::operations::get_all_workflows;
     use crate::tests::mocks::{
@@ -424,4 +464,97 @@ mod tests {
         })
         .await;
     }
+
+    #[sqlx::test]
+    async fn auto_build_success_comment(pool: sqlx::PgPool) {
+        run_test(pool, |mut tester| async {
+            tester.create_branch(AUTO_BRANCH_NAME).expect_suites(1);
+
+            tester.post_comment("@bors r+").await?;
+            tester.expect_comments(1).await;
+
+            tester.process_merge_queue().await;
+            tester.expect_comments(1).await;
+
+            tester.workflow_success(tester.auto_branch()).await?;
+            tester.process_merge_queue().await;
+            insta::assert_snapshot!(
+                tester.get_comment().await?,
+                @r"
+            :sunny: Test successful - [Workflow1](https://github.com/workflows/Workflow1/1)
+            Approved by: `default-user`
+            Pushing merge-main-sha1-pr-1-sha-0 to `main`...
+            "
+            );
+
+            Ok(tester)
+        })
+        .await;
+    }
+
+    #[sqlx::test]
+    async fn auto_build_check_run_success(pool: sqlx::PgPool) {
+        run_test(pool, |mut tester| async {
+            tester.create_branch(AUTO_BRANCH_NAME).expect_suites(1);
+
+            tester.post_comment("@bors r+").await?;
+            tester.expect_comments(1).await;
+
+            tester.process_merge_queue().await;
+            tester.expect_comments(1).await;
+
+            tester.workflow_success(tester.auto_branch()).await?;
+            tester.process_merge_queue().await;
+            tester.expect_comments(1).await;
+
+            tester.expect_check_run(
+                &tester.default_pr().await.get_gh_pr().head_sha,
+                AUTO_BUILD_CHECK_RUN_NAME,
+                AUTO_BUILD_CHECK_RUN_NAME,
+                CheckRunStatus::Completed,
+                Some(CheckRunConclusion::Success),
+            );
+
+            Ok(tester)
+        })
+        .await;
+    }
+
+    #[sqlx::test]
+    async fn auto_build_success_labels(pool: sqlx::PgPool) {
+        let github = GitHubState::default().with_default_config(
+            r#"
+merge_queue_enabled = true
+
+[labels]
+succeeded = ["+foo", "+bar", "-baz"]
+"#,
+        );
+
+        BorsBuilder::new(pool)
+            .github(github)
+            .run_test(|mut tester| async {
+                tester.create_branch(AUTO_BRANCH_NAME).expect_suites(1);
+                tester.post_comment("@bors r+").await?;
+                tester.expect_comments(1).await;
+
+                tester.process_merge_queue().await;
+                tester.expect_comments(1).await;
+
+                let repo = tester.default_repo();
+                repo.lock()
+                    .get_pr(default_pr_number())
+                    .check_added_labels(&[]);
+                tester.workflow_success(tester.auto_branch()).await?;
+                tester.process_merge_queue().await;
+                tester.expect_comments(1).await;
+
+                let pr = repo.lock().get_pr(default_pr_number()).clone();
+                pr.check_added_labels(&["foo", "bar"]);
+                pr.check_removed_labels(&["baz"]);
+
+                Ok(tester)
+            })
+            .await;
+    }
 }

src/bors/merge_queue.rs

@@ -6,8 +6,8 @@ use tokio::sync::mpsc;
 use tracing::Instrument;
 
 use crate::BorsContext;
-use crate::bors::RepositoryState;
-use crate::bors::comment::auto_build_started_comment;
+use crate::bors::comment::{auto_build_started_comment, auto_build_succeeded_comment};
+use crate::bors::{PullRequestStatus, RepositoryState};
 use crate::database::{BuildStatus, PullRequestModel};
 use crate::github::api::client::GithubRepositoryClient;
 use crate::github::api::operations::ForcePush;
@@ -84,9 +84,39 @@ pub async fn merge_queue_tick(ctx: Arc<BorsContext>) -> anyhow::Result<()> {
             let pr_num = pr.number;
 
             if let Some(auto_build) = &pr.auto_build {
+                let commit_sha = CommitSha(auto_build.commit_sha.clone());
+
                 match auto_build.status {
                     // Build successful - point the base branch to the merged commit.
                     BuildStatus::Success => {
+                        let workflows = ctx.db.get_workflows_for_build(auto_build).await?;
+                        let comment = auto_build_succeeded_comment(
+                            &workflows,
+                            pr.approver().unwrap_or("<unknown>"),
+                            &commit_sha,
+                            &pr.base_branch,
+                        );
+                        repo.client.post_comment(pr.number, comment).await?;
+
+                        match repo
+                            .client
+                            .set_branch_to_sha(&pr.base_branch, &commit_sha, ForcePush::No)
+                            .await
+                        {
+                            Ok(()) => {
+                                tracing::info!("Auto build succeeded and merged for PR {pr_num}");
+
+                                ctx.db
+                                    .set_pr_status(
+                                        &pr.repository,
+                                        pr.number,
+                                        PullRequestStatus::Merged,
+                                    )
+                                    .await?;
+                            }
+                            Err(_) => {}
+                        };
+
                         // Break to give GitHub time to update the base branch.
                         break;
                     }
@@ -337,7 +367,7 @@ mod tests {
     }
 
     #[sqlx::test]
-    async fn auto_workflow_started_comment(pool: sqlx::PgPool) {
+    async fn auto_build_started_comment(pool: sqlx::PgPool) {
         run_test(pool, |mut tester| async {
             tester.create_branch(AUTO_BRANCH_NAME).expect_suites(1);
 

src/config.rs

@@ -69,6 +69,8 @@ where
         Try,
         TrySucceed,
         TryFailed,
+        Succeeded,
+        Failed,
     }
 
     impl From<Trigger> for LabelTrigger {
@@ -79,6 +81,8 @@ where
                 Trigger::Try => LabelTrigger::TryBuildStarted,
                 Trigger::TrySucceed => LabelTrigger::TryBuildSucceeded,
                 Trigger::TryFailed => LabelTrigger::TryBuildFailed,
+                Trigger::Succeeded => LabelTrigger::Succeeded,
+                Trigger::Failed => LabelTrigger::Failed,
             }
         }
     }
@@ -206,9 +210,11 @@ approve = ["+approved"]
 try = ["+foo", "-bar"]
 try_succeed = ["+foobar", "+foo", "+baz"]
 try_failed = []
+auto_succeed = ["+foobar", "-foo"]
+auto_failed = ["+bar", "+baz"]
 "#;
         let config = load_config(content);
-        insta::assert_debug_snapshot!(config.labels.into_iter().collect::<BTreeMap<_, _>>(), @r###"
+        insta::assert_debug_snapshot!(config.labels.into_iter().collect::<BTreeMap<_, _>>(), @r#"
         {
             Approved: [
                 Add(
@@ -240,8 +246,24 @@ try_failed = []
                 ),
             ],
             TryBuildFailed: [],
+            AutoBuildSucceeded: [
+                Add(
+                    "foobar",
+                ),
+                Remove(
+                    "foo",
+                ),
+            ],
+            AutoBuildFailed: [
+                Add(
+                    "bar",
+                ),
+                Add(
+                    "baz",
+                ),
+            ],
         }
-        "###);
+        "#);
     }
 
     #[test]

src/github/labels.rs

@@ -6,6 +6,8 @@ pub enum LabelTrigger {
     TryBuildStarted,
     TryBuildSucceeded,
     TryBuildFailed,
+    Succeeded,
+    Failed,
 }
 
 #[derive(Debug, Eq, PartialEq)]