Merge pull request #109 from rust-lang/tests-end-to-end

Finish the move to end-to-end tests

Author: Kobzol

Cargo.lock

@@ -36,7 +36,7 @@ axum = "0.7.4"
 tower = { version = "0.4", features = ["limit"] }
 jsonwebtoken = "9.2.0"
 url = "2.3"
-reqwest = { version = "0.11", features = ["json", "rustls-tls"], default-features = false }
+reqwest = { version = "0.12", features = ["json", "rustls-tls"], default-features = false }
 http = "1.1.0"
 
 # Cryptography
@@ -59,6 +59,9 @@ derive_builder = "0.20.0"
 wiremock = "0.6.0"
 base64 = "0.22.1"
 tracing-test = "0.2.4"
+regex = "1.10.4"
+parking_lot = "0.12.3"
+once_cell = "1.19.0"
 
 [profile.release]
 debug = 1

Cargo.toml

@@ -88,7 +88,9 @@ fn try_main(opts: Opts) -> anyhow::Result<()> {
             "https://api.github.com".to_string(),
             opts.private_key.into_bytes().into(),
         )?;
-        let repos = client.load_repositories(&team_api).await?;
+        let repos = RepositoryLoader::new(client.clone())
+            .load_repositories(&team_api)
+            .await?;
         Ok::<_, anyhow::Error>((client, repos))
     })?;
 

src/bin/bors.rs

@@ -3,21 +3,21 @@ use std::{
     sync::{Arc, RwLock},
 };
 
-use crate::{bors::command::CommandParser, database::DbClient, github::GithubRepoName};
+use crate::{bors::command::CommandParser, github::GithubRepoName, PgDbClient};
 
-use super::{RepositoryClient, RepositoryState};
+use super::RepositoryState;
 
-pub struct BorsContext<Client: RepositoryClient> {
+pub struct BorsContext {
     pub parser: CommandParser,
-    pub db: Arc<dyn DbClient>,
-    pub repositories: RwLock<HashMap<GithubRepoName, Arc<RepositoryState<Client>>>>,
+    pub db: Arc<PgDbClient>,
+    pub repositories: RwLock<HashMap<GithubRepoName, Arc<RepositoryState>>>,
 }
 
-impl<Client: RepositoryClient> BorsContext<Client> {
+impl BorsContext {
     pub fn new(
         parser: CommandParser,
-        db: Arc<dyn DbClient>,
-        repositories: HashMap<GithubRepoName, Arc<RepositoryState<Client>>>,
+        db: Arc<PgDbClient>,
+        repositories: HashMap<GithubRepoName, Arc<RepositoryState>>,
     ) -> Self {
         let repositories = RwLock::new(repositories);
         Self {

src/bors/context.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 
 use crate::bors::Comment;
-use crate::bors::RepositoryClient;
 use crate::bors::RepositoryState;
 use crate::github::PullRequest;
 
@@ -12,8 +11,8 @@ const HELP_MESSAGE: &str = r#"
 - help: Print this help message
 "#;
 
-pub(super) async fn command_help<Client: RepositoryClient>(
-    repo: Arc<RepositoryState<Client>>,
+pub(super) async fn command_help(
+    repo: Arc<RepositoryState>,
     pr: &PullRequest,
 ) -> anyhow::Result<()> {
     repo.client
@@ -30,8 +29,8 @@ mod tests {
     #[sqlx::test]
     async fn help_command(pool: sqlx::PgPool) {
         run_test(pool, |mut tester| async {
-            tester.post_comment("@bors help").await;
-            assert_eq!(tester.get_comment().await, HELP_MESSAGE);
+            tester.post_comment("@bors help").await?;
+            assert_eq!(tester.get_comment().await?, HELP_MESSAGE);
             Ok(tester)
         })
         .await;

src/bors/handlers/help.rs

@@ -1,13 +1,13 @@
 use itertools::Itertools;
 use tracing::log;
 
-use crate::bors::{RepositoryClient, RepositoryState};
+use crate::bors::RepositoryState;
 use crate::github::{LabelModification, LabelTrigger, PullRequestNumber};
 
 /// If there are any label modifications that should be performed on the given PR when `trigger`
 /// happens, this function will perform them.
-pub async fn handle_label_trigger<Client: RepositoryClient>(
-    repo: &RepositoryState<Client>,
+pub async fn handle_label_trigger(
+    repo: &RepositoryState,
     pr: PullRequestNumber,
     trigger: LabelTrigger,
 ) -> anyhow::Result<()> {

src/bors/handlers/labels.rs

@@ -12,10 +12,11 @@ use crate::bors::handlers::trybuild::{command_try_build, command_try_cancel, TRY
 use crate::bors::handlers::workflow::{
     handle_check_suite_completed, handle_workflow_completed, handle_workflow_started,
 };
-use crate::bors::{BorsContext, Comment, RepositoryClient, RepositoryLoader, RepositoryState};
-use crate::database::DbClient;
-use crate::utils::logging::LogError;
-use crate::TeamApiClient;
+use crate::bors::{BorsContext, Comment, RepositoryLoader, RepositoryState};
+use crate::{PgDbClient, TeamApiClient};
+
+#[cfg(test)]
+use crate::tests::util::TestSyncMarker;
 
 mod help;
 mod labels;
@@ -24,18 +25,21 @@ mod refresh;
 mod trybuild;
 mod workflow;
 
+#[cfg(test)]
+pub static WAIT_FOR_WORKFLOW_STARTED: TestSyncMarker = TestSyncMarker::new();
+
 /// This function executes a single BORS repository event
-pub async fn handle_bors_repository_event<Client: RepositoryClient>(
+pub async fn handle_bors_repository_event(
     event: BorsRepositoryEvent,
-    ctx: Arc<BorsContext<Client>>,
+    ctx: Arc<BorsContext>,
 ) -> anyhow::Result<()> {
     let db = Arc::clone(&ctx.db);
     let Some(repo) = ctx
         .repositories
         .read()
         .unwrap()
         .get(event.repository())
-        .map(Arc::clone)
+        .cloned()
     else {
         return Err(anyhow::anyhow!(
             "Repository {} not found in the bot state",
@@ -61,7 +65,6 @@ pub async fn handle_bors_repository_event<Client: RepositoryClient>(
                 .instrument(span.clone())
                 .await
             {
-                span.log_error(error);
                 repo.client
                     .post_comment(
                         pr_number,
@@ -71,6 +74,7 @@ pub async fn handle_bors_repository_event<Client: RepositoryClient>(
                     )
                     .await
                     .context("Cannot send comment reacting to an error")?;
+                return Err(error.context("Cannot perform command"));
             }
         }
 
@@ -80,47 +84,44 @@ pub async fn handle_bors_repository_event<Client: RepositoryClient>(
                 repo = payload.repository.to_string(),
                 id = payload.run_id.into_inner()
             );
-            if let Err(error) = handle_workflow_started(db, payload)
+            handle_workflow_started(db, payload)
                 .instrument(span.clone())
-                .await
-            {
-                span.log_error(error);
-            }
+                .await?;
+
+            #[cfg(test)]
+            WAIT_FOR_WORKFLOW_STARTED.mark();
         }
         BorsRepositoryEvent::WorkflowCompleted(payload) => {
             let span = tracing::info_span!(
                 "Workflow completed",
                 repo = payload.repository.to_string(),
                 id = payload.run_id.into_inner()
             );
-            if let Err(error) = handle_workflow_completed(repo, db, payload)
+            handle_workflow_completed(repo, db, payload)
                 .instrument(span.clone())
-                .await
-            {
-                span.log_error(error);
-            }
+                .await?;
         }
         BorsRepositoryEvent::CheckSuiteCompleted(payload) => {
             let span = tracing::info_span!(
                 "Check suite completed",
                 repo = payload.repository.to_string(),
             );
-            if let Err(error) = handle_check_suite_completed(repo, db, payload)
+            handle_check_suite_completed(repo, db, payload)
                 .instrument(span.clone())
-                .await
-            {
-                span.log_error(error);
-            }
+                .await?;
         }
     }
     Ok(())
 }
 
+#[cfg(test)]
+pub static WAIT_FOR_REFRESH: TestSyncMarker = TestSyncMarker::new();
+
 /// This function executes a single BORS global event
-pub async fn handle_bors_global_event<Client: RepositoryClient>(
+pub async fn handle_bors_global_event(
     event: BorsGlobalEvent,
-    ctx: Arc<BorsContext<Client>>,
-    repo_loader: &dyn RepositoryLoader<Client>,
+    ctx: Arc<BorsContext>,
+    repo_loader: &RepositoryLoader,
     team_api_client: &TeamApiClient,
 ) -> anyhow::Result<()> {
     let db = Arc::clone(&ctx.db);
@@ -133,7 +134,7 @@ pub async fn handle_bors_global_event<Client: RepositoryClient>(
         }
         BorsGlobalEvent::Refresh => {
             let span = tracing::info_span!("Refresh");
-            let repos: Vec<Arc<RepositoryState<Client>>> =
+            let repos: Vec<Arc<RepositoryState>> =
                 ctx.repositories.read().unwrap().values().cloned().collect();
             futures::future::join_all(repos.into_iter().map(|repo| {
                 let repo = Arc::clone(&repo);
@@ -146,15 +147,18 @@ pub async fn handle_bors_global_event<Client: RepositoryClient>(
             }))
             .instrument(span)
             .await;
+
+            #[cfg(test)]
+            WAIT_FOR_REFRESH.mark();
         }
     }
     Ok(())
 }
 
-async fn handle_comment<Client: RepositoryClient>(
-    repo: Arc<RepositoryState<Client>>,
-    database: Arc<dyn DbClient>,
-    ctx: Arc<BorsContext<Client>>,
+async fn handle_comment(
+    repo: Arc<RepositoryState>,
+    database: Arc<PgDbClient>,
+    ctx: Arc<BorsContext>,
     comment: PullRequestComment,
 ) -> anyhow::Result<()> {
     let pr_number = comment.pr_number;
@@ -237,9 +241,9 @@ async fn handle_comment<Client: RepositoryClient>(
     Ok(())
 }
 
-async fn reload_repos<Client: RepositoryClient>(
-    ctx: Arc<BorsContext<Client>>,
-    repo_loader: &dyn RepositoryLoader<Client>,
+async fn reload_repos(
+    ctx: Arc<BorsContext>,
+    repo_loader: &RepositoryLoader,
     team_api_client: &TeamApiClient,
 ) -> anyhow::Result<()> {
     let reloaded_repos = repo_loader.load_repositories(team_api_client).await?;
@@ -281,7 +285,7 @@ mod tests {
         run_test(pool, |mut tester| async {
             tester
                 .post_comment(Comment::from("@bors ping").with_author(User::bors_bot()))
-                .await;
+                .await?;
             // Returning here will make sure that no comments were received
             Ok(tester)
         })

src/bors/handlers/mod.rs

@@ -1,12 +1,11 @@
 use std::sync::Arc;
 
 use crate::bors::Comment;
-use crate::bors::RepositoryClient;
 use crate::bors::RepositoryState;
 use crate::github::PullRequest;
 
-pub(super) async fn command_ping<Client: RepositoryClient>(
-    repo: Arc<RepositoryState<Client>>,
+pub(super) async fn command_ping(
+    repo: Arc<RepositoryState>,
     pr: &PullRequest,
 ) -> anyhow::Result<()> {
     repo.client
@@ -22,8 +21,8 @@ mod tests {
     #[sqlx::test]
     async fn ping_command(pool: sqlx::PgPool) {
         run_test(pool, |mut tester| async {
-            tester.post_comment("@bors ping").await;
-            assert_eq!(tester.get_comment().await, "Pong 🏓!");
+            tester.post_comment("@bors ping").await?;
+            assert_eq!(tester.get_comment().await?, "Pong 🏓!");
             Ok(tester)
         })
         .await;