Complete auto build

- Post comment
- Update check run
- Update label

Author: Sakib25800

rust-bors.example.toml

@@ -19,6 +19,8 @@ approve = ["+approved"]
 try = ["+foo", "-bar"]
 try_succeed = ["+foobar", "+foo", "+baz"]
 try_failed = []
+succeeded = ["+foo", "+bar"]
+failed = ["+foo", "+bar"]
 
 # Labels that will block approval when present on a PR
 # (Optional)

src/bors/comment.rs

@@ -283,3 +283,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

@@ -1,6 +1,7 @@
 use crate::PgDbClient;
 use crate::bors::comment::{build_failed_comment, try_build_succeeded_comment};
 use crate::bors::event::{WorkflowRunCompleted, WorkflowRunStarted};
+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;
@@ -184,21 +185,26 @@ async fn maybe_complete_build(
     let has_failure = db_workflow_runs
         .iter()
         .any(|check| matches!(check.status, WorkflowStatus::Failure));
-
-    let (status, trigger) = if has_failure {
-        (BuildStatus::Failure, LabelTrigger::TryBuildFailed)
-    } else {
-        (BuildStatus::Success, LabelTrigger::TryBuildSucceeded)
+    let build_succeeded = !has_failure;
+    let pr_num = pr.number;
+    let branch = payload.branch.as_str();
+
+    let (status, trigger) = match (branch, build_succeeded) {
+        (TRY_BRANCH_NAME, true) => (BuildStatus::Success, LabelTrigger::TryBuildSucceeded),
+        (TRY_BRANCH_NAME, false) => (BuildStatus::Failure, LabelTrigger::TryBuildFailed),
+        (AUTO_BRANCH_NAME, true) => (BuildStatus::Success, LabelTrigger::AutoBuildSucceeded),
+        (AUTO_BRANCH_NAME, false) => (BuildStatus::Failure, LabelTrigger::AutoBuildFailed),
+        _ => unreachable!("Branch should be bors observed branch"),
     };
-    db.update_build_status(&build, status).await?;
 
-    handle_label_trigger(repo, pr.number, trigger).await?;
+    db.update_build_status(&build, status).await?;
+    handle_label_trigger(repo, pr_num, trigger).await?;
 
     if let Some(check_run_id) = build.check_run_id {
-        let (status, conclusion) = if has_failure {
-            (CheckRunStatus::Completed, Some(CheckRunConclusion::Failure))
-        } else {
+        let (status, conclusion) = if build_succeeded {
             (CheckRunStatus::Completed, Some(CheckRunConclusion::Success))
+        } else {
+            (CheckRunStatus::Completed, Some(CheckRunConclusion::Failure))
         };
 
         if let Err(error) = repo
@@ -212,10 +218,21 @@ async fn maybe_complete_build(
 
     db_workflow_runs.sort_by(|a, b| a.name.cmp(&b.name));
 
-    let message = if !has_failure {
-        tracing::info!("Build succeeded");
-        try_build_succeeded_comment(&db_workflow_runs, payload.commit_sha, &build)
+    let comment_opt = if build_succeeded {
+        tracing::info!("Build succeeded for PR {pr_num}");
+
+        if branch == TRY_BRANCH_NAME {
+            Some(try_build_succeeded_comment(
+                &db_workflow_runs,
+                payload.commit_sha,
+                &build,
+            ))
+        } else {
+            None
+        }
     } else {
+        tracing::info!("Build failed for PR {pr_num}");
+
         // Download failed jobs
         let mut workflow_runs: Vec<FailedWorkflowRun> = vec![];
         for workflow_run in db_workflow_runs {
@@ -235,10 +252,12 @@ async fn maybe_complete_build(
             })
         }
 
-        tracing::info!("Build failed");
-        build_failed_comment(repo.repository(), workflow_runs)
+        Some(build_failed_comment(repo.repository(), workflow_runs))
     };
-    repo.client.post_comment(pr.number, message).await?;
+
+    if let Some(comment) = comment_opt {
+        repo.client.post_comment(pr_num, comment).await?;
+    }
 
     // Trigger merge queue when an auto build completes
     if payload.branch == AUTO_BRANCH_NAME {
@@ -273,10 +292,24 @@ async fn get_failed_jobs(
 
 #[cfg(test)]
 mod tests {
-    use crate::database::WorkflowStatus;
+    use octocrab::params::checks::{CheckRunConclusion, CheckRunStatus};
+
+    use crate::bors::merge_queue::AUTO_BUILD_CHECK_RUN_NAME;
     use crate::database::operations::get_all_workflows;
+    use crate::database::{BuildStatus, WorkflowStatus};
     use crate::tests::BorsTester;
-    use crate::tests::mocks::{Branch, WorkflowEvent, WorkflowRunData, run_test};
+    use crate::tests::mocks::{
+        BorsBuilder, Branch, GitHubState, WorkflowEvent, WorkflowRunData, default_pr_number,
+        run_test,
+    };
+
+    fn gh_state_with_merge_queue() -> GitHubState {
+        GitHubState::default().with_default_config(
+            r#"
+      merge_queue_enabled = true
+      "#,
+        )
+    }
 
     #[sqlx::test]
     async fn workflow_started_unknown_build(pool: sqlx::PgPool) {
@@ -425,4 +458,156 @@ mod tests {
         })
         .await;
     }
+
+    #[sqlx::test]
+    async fn auto_build_success_updates_check_run(pool: sqlx::PgPool) {
+        BorsBuilder::new(pool)
+            .github(gh_state_with_merge_queue())
+            .run_test(async |tester| {
+                tester.post_comment("@bors r+").await?;
+                tester.expect_comments(1).await;
+                tester.process_merge_queue().await;
+                tester.expect_comments(1).await;
+
+                tester.workflow_full_success(tester.auto_branch()).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(())
+            })
+            .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(async |tester| {
+                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_full_success(tester.auto_branch()).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(())
+            })
+            .await;
+    }
+
+    #[sqlx::test]
+    async fn auto_build_failed_labels(pool: sqlx::PgPool) {
+        let github = GitHubState::default().with_default_config(
+            r#"
+merge_queue_enabled = true
+
+[labels]
+failed = ["+foo", "+bar", "-baz"]
+      "#,
+        );
+
+        BorsBuilder::new(pool)
+            .github(github)
+            .run_test(async |tester| {
+                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_full_failure(tester.auto_branch()).await?;
+                tester
+                    .wait_for_default_pr(|pr| {
+                        pr.auto_build.as_ref().unwrap().status == BuildStatus::Failure
+                    })
+                    .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(())
+            })
+            .await;
+    }
+
+    #[sqlx::test]
+    async fn auto_build_failed_comment(pool: sqlx::PgPool) {
+        BorsBuilder::new(pool)
+            .github(gh_state_with_merge_queue())
+            .run_test(async |tester| {
+                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_full_failure(tester.auto_branch()).await?;
+                tester.wait_for_default_pr(|pr| {
+                    pr.auto_build.as_ref().unwrap().status == BuildStatus::Failure
+                }).await?;
+                insta::assert_snapshot!(
+                    tester.get_comment().await?,
+                    @":broken_heart: Test failed ([Workflow1](https://github.com/workflows/Workflow1/1))"
+                );
+
+                Ok(())
+            })
+            .await;
+    }
+
+    #[sqlx::test]
+    async fn auto_build_failure_updates_check_run(pool: sqlx::PgPool) {
+        BorsBuilder::new(pool)
+            .github(gh_state_with_merge_queue())
+            .run_test(async |tester| {
+                tester.post_comment("@bors r+").await?;
+                tester.expect_comments(1).await;
+                tester.process_merge_queue().await;
+                tester.expect_comments(1).await;
+
+                tester.workflow_full_failure(tester.auto_branch()).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::Failure),
+                );
+                Ok(())
+            })
+            .await;
+    }
 }