Add tests

Kobzol · Kobzol · commit 16a6647a3f3e · 2025-07-18T22:55:32.000+02:00
diff --git a/src/bors/comment.rs b/src/bors/comment.rs
@@ -115,8 +115,7 @@ pub fn build_failed_comment(
 
         let mut failed_jobs: Vec<Job> = failed_workflows
             .into_iter()
-            .map(|w| w.failed_jobs)
-            .flatten()
+            .flat_map(|w| w.failed_jobs)
             .collect();
         failed_jobs.sort_by(|l, r| l.name.cmp(&r.name));
 
diff --git a/src/bors/handlers/trybuild.rs b/src/bors/handlers/trybuild.rs
@@ -417,9 +417,10 @@ mod tests {
     use crate::github::CommitSha;
     use crate::tests::BorsTester;
     use crate::tests::mocks::{
-        BorsBuilder, Comment, GitHubState, User, WorkflowEvent, WorkflowRunData, default_pr_number,
-        default_repo_name, run_test,
+        BorsBuilder, Comment, GitHubState, User, WorkflowEvent, WorkflowJob, WorkflowRunData,
+        default_pr_number, default_repo_name, run_test,
     };
+    use octocrab::models::JobId;
     use octocrab::params::checks::{CheckRunConclusion, CheckRunStatus};
 
     #[sqlx::test]
@@ -457,6 +458,42 @@ mod tests {
         .await;
     }
 
+    #[sqlx::test]
+    async fn try_failure_job(pool: sqlx::PgPool) {
+        run_test(pool, async |tester: &mut BorsTester| {
+            tester.post_comment("@bors try").await?;
+            tester.expect_comments(1).await;
+
+            let mut workflow = WorkflowRunData::from(tester.try_branch());
+            workflow.jobs.push(WorkflowJob {
+                id: JobId(42),
+                status: WorkflowStatus::Failure,
+            });
+            workflow.jobs.push(WorkflowJob {
+                id: JobId(50),
+                status: WorkflowStatus::Failure,
+            });
+            workflow.jobs.push(WorkflowJob {
+                id: JobId(51),
+                status: WorkflowStatus::Success,
+            });
+
+            tester.default_repo().lock().update_workflow_run(workflow.clone(), WorkflowStatus::Pending);
+            tester.workflow_full_failure(workflow).await?;
+            insta::assert_snapshot!(
+                tester.get_comment().await?,
+                @r"
+            :broken_heart: Test failed ([Workflow1](https://github.com/workflows/Workflow1/1)). Failed jobs:
+
+            - `Job 42` ([web logs](https://github.com/job-logs/42), [extended logs](https://triage.rust-lang.org/gha-logs/rust-lang/borstest/42))
+            - `Job 50` ([web logs](https://github.com/job-logs/50), [extended logs](https://triage.rust-lang.org/gha-logs/rust-lang/borstest/50))
+            "
+            );
+            Ok(())
+        })
+            .await;
+    }
+
     #[sqlx::test]
     async fn try_no_permissions(pool: sqlx::PgPool) {
         run_test(pool, async |tester| {
diff --git a/src/bors/handlers/workflow.rs b/src/bors/handlers/workflow.rs
@@ -219,7 +219,7 @@ async fn maybe_complete_build(
         // Download failed jobs
         let mut workflow_runs: Vec<FailedWorkflowRun> = vec![];
         for workflow_run in db_workflow_runs {
-            let failed_jobs = match get_failed_jobs(&repo, &workflow_run).await {
+            let failed_jobs = match get_failed_jobs(repo, &workflow_run).await {
                 Ok(jobs) => jobs,
                 Err(error) => {
                     tracing::error!(
diff --git a/src/github/api/client.rs b/src/github/api/client.rs
@@ -286,11 +286,7 @@ impl GithubRepositoryClient {
 
             // Cancel all workflows in parallel
             futures::future::join_all(run_ids.iter().map(|run_id| {
-                actions.cancel_workflow_run(
-                    self.repo_name.owner(),
-                    self.repo_name.name(),
-                    (*run_id).into(),
-                )
+                actions.cancel_workflow_run(self.repo_name.owner(), self.repo_name.name(), *run_id)
             }))
             .await
             .into_iter()
diff --git a/src/tests/mocks/mod.rs b/src/tests/mocks/mod.rs
@@ -25,6 +25,7 @@ pub use repository::default_branch_name;
 pub use repository::default_repo_name;
 pub use user::User;
 pub use workflow::WorkflowEvent;
+pub use workflow::WorkflowJob;
 pub use workflow::WorkflowRunData;
 
 mod app;
diff --git a/src/tests/mocks/repository.rs b/src/tests/mocks/repository.rs
@@ -1,21 +1,23 @@
 use std::sync::Arc;
 use std::{collections::HashMap, time::SystemTime};
 
+use super::user::{GitHubUser, User};
 use crate::bors::PullRequestStatus;
-use base64::Engine;
-use chrono::{DateTime, Utc};
-use octocrab::models::CheckSuiteId;
-use octocrab::models::pulls::MergeableState;
-use octocrab::models::repos::Object;
-use octocrab::models::repos::Object::Commit;
-
 use crate::database::WorkflowStatus;
 use crate::github::{GithubRepoName, PullRequestNumber};
 use crate::permissions::PermissionType;
 use crate::tests::mocks::comment::Comment;
 use crate::tests::mocks::permissions::Permissions;
 use crate::tests::mocks::pull_request::mock_pull_requests;
+use crate::tests::mocks::workflow::WorkflowJob;
 use crate::tests::mocks::{GitHubState, WorkflowRunData, default_pr_number, dynamic_mock_req};
+use base64::Engine;
+use chrono::{DateTime, Utc};
+use octocrab::models::pulls::MergeableState;
+use octocrab::models::repos::Object;
+use octocrab::models::repos::Object::Commit;
+use octocrab::models::workflows::{Conclusion, Status, Step};
+use octocrab::models::{CheckSuiteId, JobId, RunId};
 use parking_lot::Mutex;
 use serde::Serialize;
 use tokio::sync::mpsc::Sender;
@@ -25,8 +27,6 @@ use wiremock::{
     matchers::{method, path},
 };
 
-use super::user::{GitHubUser, User};
-
 #[derive(Clone, Debug)]
 pub struct CheckRunData {
     pub name: String,
@@ -386,6 +386,7 @@ pub async fn mock_repo(
     mock_cancel_workflow(repo.clone(), mock_server).await;
     mock_check_runs(repo.clone(), mock_server).await;
     mock_workflow_runs(repo.clone(), mock_server).await;
+    mock_workflow_jobs(repo.clone(), mock_server).await;
     mock_config(repo, mock_server).await;
 }
 
@@ -580,8 +581,8 @@ async fn mock_workflow_runs(repo: Arc<Mutex<Repo>>, mock_server: &MockServer) {
     #[derive(serde::Serialize, Debug)]
     struct WorkflowRunResponse {
         id: octocrab::models::RunId,
-        status: String,
-        conclusion: Option<String>,
+        status: Status,
+        conclusion: Option<Conclusion>,
     }
 
     #[derive(serde::Serialize, Debug)]
@@ -607,25 +608,64 @@ async fn mock_workflow_runs(repo: Arc<Mutex<Repo>>, mock_server: &MockServer) {
             let response = WorkflowRunsResponse {
                 workflow_runs: workflow_runs
                     .into_iter()
-                    .map(|run| WorkflowRunResponse {
-                        id: run.workflow_run.run_id,
-                        status: match run.status {
-                            WorkflowStatus::Pending => "pending",
-                            WorkflowStatus::Success | WorkflowStatus::Failure => "completed",
+                    .map(|run| {
+                        let (status, conclusion) = status_to_gh(run.status);
+                        WorkflowRunResponse {
+                            id: run.workflow_run.run_id,
+                            status,
+                            conclusion,
                         }
-                        .to_string(),
-                        conclusion: match run.status {
-                            WorkflowStatus::Success => Some("success".to_string()),
-                            WorkflowStatus::Failure => Some("failure".to_string()),
-                            _ => None,
-                        },
                     })
                     .collect(),
             };
             ResponseTemplate::new(200).set_body_json(response)
         },
         "GET",
-        format!("^/repos/{repo_name}/actions/runs"),
+        format!("^/repos/{repo_name}/actions/runs$"),
+    )
+    .mount(mock_server)
+    .await;
+}
+
+/// Returns (status, conclusion).
+fn status_to_gh(status: WorkflowStatus) -> (Status, Option<Conclusion>) {
+    let conclusion = match status {
+        WorkflowStatus::Success => Some(Conclusion::Success),
+        WorkflowStatus::Failure => Some(Conclusion::Failure),
+        _ => None,
+    };
+    let status = match status {
+        WorkflowStatus::Pending => Status::Pending,
+        WorkflowStatus::Success | WorkflowStatus::Failure => Status::Completed,
+    };
+    (status, conclusion)
+}
+
+async fn mock_workflow_jobs(repo: Arc<Mutex<Repo>>, mock_server: &MockServer) {
+    let repo_name = repo.lock().name.clone();
+    dynamic_mock_req(
+        move |_req: &Request, [run_id]: [&str; 1]| {
+            let repo = repo.lock();
+            let run_id: RunId = run_id.parse::<u64>().expect("Non-integer run id").into();
+            let workflow_run = repo
+                .workflow_runs
+                .iter()
+                .find(|w| w.workflow_run.run_id == run_id)
+                .unwrap_or_else(|| panic!("Workflow run with ID {run_id} not found"));
+
+            let response = GitHubWorkflowJobs {
+                total_count: workflow_run.workflow_run.jobs.len() as u64,
+                jobs: workflow_run
+                    .workflow_run
+                    .jobs
+                    .iter()
+                    .map(|job| workflow_job_to_gh(job, run_id))
+                    .collect(),
+            };
+            ResponseTemplate::new(200).set_body_json(response)
+        },
+        "GET",
+        format!("^/repos/{repo_name}/actions/runs/(.*)/jobs"),
     )
     .mount(mock_server)
     .await;
@@ -923,3 +963,73 @@ struct GitHubRef {
     url: Url,
     object: Object,
 }
+
+#[derive(Serialize)]
+struct GitHubWorkflowJobs {
+    total_count: u64,
+    jobs: Vec<GitHubWorkflowJob>,
+}
+
+#[derive(Serialize)]
+struct GitHubWorkflowJob {
+    id: JobId,
+    run_id: RunId,
+    workflow_name: String,
+    head_branch: String,
+    run_url: Url,
+    run_attempt: u32,
+
+    node_id: String,
+    head_sha: String,
+    url: Url,
+    html_url: Url,
+    status: Status,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    conclusion: Option<Conclusion>,
+    created_at: DateTime<Utc>,
+    started_at: DateTime<Utc>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    completed_at: Option<DateTime<Utc>>,
+    name: String,
+    steps: Vec<Step>,
+    check_run_url: String,
+    labels: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    runner_id: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    runner_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    runner_group_id: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    runner_group_name: Option<String>,
+}
+
+fn workflow_job_to_gh(job: &WorkflowJob, run_id: RunId) -> GitHubWorkflowJob {
+    let WorkflowJob { id, status } = job;
+    let (status, conclusion) = status_to_gh(*status);
+    GitHubWorkflowJob {
+        id: *id,
+        run_id,
+        workflow_name: "".to_string(),
+        head_branch: "".to_string(),
+        run_url: "https://test.com".parse().unwrap(),
+        run_attempt: 0,
+        node_id: "".to_string(),
+        head_sha: "".to_string(),
+        url: "https://test.com".parse().unwrap(),
+        html_url: format!("https://github.com/job-logs/{id}").parse().unwrap(),
+        status,
+        conclusion,
+        created_at: Default::default(),
+        started_at: Default::default(),
+        completed_at: None,
+        name: format!("Job {id}"),
+        steps: vec![],
+        check_run_url: "".to_string(),
+        labels: vec![],
+        runner_id: None,
+        runner_name: None,
+        runner_group_id: None,
+        runner_group_name: None,
+    }
+}
diff --git a/src/tests/mocks/workflow.rs b/src/tests/mocks/workflow.rs
@@ -1,11 +1,11 @@
-use chrono::{DateTime, Utc};
-use octocrab::models::{CheckSuiteId, RunId, WorkflowId};
-use serde::Serialize;
-use url::Url;
-
+use crate::database::WorkflowStatus;
 use crate::github::GithubRepoName;
 use crate::tests::mocks::default_repo_name;
 use crate::tests::mocks::repository::{Branch, GitHubRepository};
+use chrono::{DateTime, Utc};
+use octocrab::models::{CheckSuiteId, JobId, RunId, WorkflowId};
+use serde::Serialize;
+use url::Url;
 
 #[derive(Clone)]
 pub struct WorkflowEvent {
@@ -44,13 +44,20 @@ pub enum WorkflowEventKind {
     Completed { status: String },
 }
 
+#[derive(Clone)]
+pub struct WorkflowJob {
+    pub id: JobId,
+    pub status: WorkflowStatus,
+}
+
 #[derive(Clone)]
 pub struct WorkflowRunData {
     pub repository: GithubRepoName,
     name: String,
     pub run_id: RunId,
     pub check_suite_id: CheckSuiteId,
     pub head_branch: String,
+    pub jobs: Vec<WorkflowJob>,
     head_sha: String,
 }
 
@@ -62,6 +69,7 @@ impl WorkflowRunData {
             run_id: RunId(1),
             check_suite_id: CheckSuiteId(1),
             head_branch: branch.get_name().to_string(),
+            jobs: vec![],
             head_sha: branch.get_sha().to_string(),
         }
     }
