Restructure repository and PR mocking

Kobzol · Kobzol · commit 21da78d8065f · 2024-05-31T16:05:43.000+02:00
diff --git a/src/tests/mocks/github.rs b/src/tests/mocks/github.rs
@@ -1,21 +1,51 @@
 use octocrab::Octocrab;
+use std::collections::HashMap;
 use wiremock::MockServer;
 
 use crate::create_github_client;
+use crate::github::GithubRepoName;
 use crate::tests::mocks::app::{default_app_id, AppHandler};
-use crate::tests::mocks::repository::RepositoriesHandler;
+use crate::tests::mocks::comment::Comment;
+use crate::tests::mocks::repository::{mock_repo, mock_repo_list};
 use crate::tests::mocks::World;
 
+/// Represents the state of a simulated GH repo.
+pub struct GitHubRepoState {
+    // We store comments from all PRs inside a single queue, because
+    // we don't necessarily know beforehand which PRs will receive comments.
+    comments_queue: tokio::sync::mpsc::Receiver<Comment>,
+    // We need a local queue to avoid skipping comments received out of order.
+    pending_comments: Vec<Comment>,
+}
+
 pub struct GitHubMockServer {
     mock_server: MockServer,
+    repos: HashMap<GithubRepoName, GitHubRepoState>,
 }
 
 impl GitHubMockServer {
     pub async fn start(world: &World) -> Self {
         let mock_server = MockServer::start().await;
-        RepositoriesHandler.mount(world, &mock_server).await;
+        mock_repo_list(world, &mock_server).await;
+
+        // Repositories are mocked separately to make it easier to
+        // pass comm. channels to them.
+        let mut repos = HashMap::default();
+        for (name, repo) in &world.repos {
+            let (comments_tx, comments_rx) = tokio::sync::mpsc::channel(1024);
+            mock_repo(repo, comments_tx, &mock_server).await;
+            repos.insert(
+                name.clone(),
+                GitHubRepoState {
+                    comments_queue: comments_rx,
+                    pending_comments: vec![],
+                },
+            );
+        }
+
         AppHandler::default().mount(&mock_server).await;
-        Self { mock_server }
+
+        Self { mock_server, repos }
     }
 
     pub fn client(&self) -> Octocrab {
diff --git a/src/tests/mocks/mod.rs b/src/tests/mocks/mod.rs
@@ -9,7 +9,6 @@ use crate::tests::mocks::permissions::TeamApiMockServer;
 use crate::TeamApiClient;
 
 pub use bors::run_test;
-pub use bors::BorsBuilder;
 pub use repository::Repo;
 pub use user::User;
 
diff --git a/src/tests/mocks/pull_request.rs b/src/tests/mocks/pull_request.rs
@@ -1,8 +1,3 @@
-use std::{
-    collections::HashMap,
-    sync::{Arc, Mutex},
-};
-
 use serde::{Deserialize, Serialize};
 use wiremock::{
     matchers::{method, path},
@@ -14,44 +9,26 @@ use super::{
     Repo,
 };
 
-/// Handles all repositories related requests
-/// Only handle one PR for now, since bors don't create PRs itself
-#[derive(Default)]
-pub(super) struct PullRequestsHandler {
-    repo: Repo,
-    number: u64,
-    comments: Arc<Mutex<HashMap<u64, Vec<Comment>>>>,
-}
-
-impl PullRequestsHandler {
-    pub(super) fn new(repo: Repo) -> Self {
-        PullRequestsHandler {
-            repo,
-            number: default_pr_number(),
-            comments: Arc::new(Mutex::new(HashMap::new())),
-        }
-    }
-    pub(super) async fn mount(&self, mock_server: &MockServer) {
+pub async fn mock_pull_requests(repo: &Repo, mock_server: &MockServer) {
+    for pr_number in &repo.known_prs {
         Mock::given(method("GET"))
-            .and(path(format!(
-                "/repos/{}/pulls/{}",
-                self.repo.name, self.number
-            )))
-            .respond_with(ResponseTemplate::new(200).set_body_json(GitHubPullRequest::default()))
+            .and(path(format!("/repos/{}/pulls/{}", repo.name, pr_number)))
+            .respond_with(
+                ResponseTemplate::new(200).set_body_json(GitHubPullRequest::new(*pr_number)),
+            )
             .mount(mock_server)
             .await;
 
-        let comments = self.comments.clone();
         Mock::given(method("POST"))
             .and(path(format!(
                 "/repos/{}/issues/{}/comments",
-                self.repo.name, self.number
+                repo.name, pr_number
             )))
             .respond_with(move |req: &Request| {
                 let comment_payload: CommentCreatePayload = req.body_json().unwrap();
                 let comment: Comment = comment_payload.into();
-                let mut comments = comments.lock().unwrap();
-                comments.entry(1).or_default().push(comment.clone());
+                // let mut comments = comments.lock().unwrap();
+                // comments.entry(1).or_default().push(comment.clone());
                 ResponseTemplate::new(201).set_body_json(GitHubComment::from(comment))
             })
             .mount(mock_server)
@@ -74,27 +51,33 @@ struct GitHubPullRequest {
     base: Box<Base>,
 }
 
-impl Default for GitHubPullRequest {
-    fn default() -> Self {
+impl GitHubPullRequest {
+    fn new(number: u64) -> Self {
         GitHubPullRequest {
             url: "https://test.com".to_string(),
-            id: 1,
-            title: format!("PR #{}", default_pr_number()),
-            body: "test".to_string(),
-            number: default_pr_number(),
+            id: number + 1000,
+            title: format!("PR #{number}"),
+            body: format!("Description of PR #{number}"),
+            number,
             head: Box::new(Head {
-                label: "test".to_string(),
-                ref_field: "test".to_string(),
-                sha: "test".to_string(),
+                label: format!("pr-{number}"),
+                ref_field: format!("pr-{number}"),
+                sha: format!("pr-{number}-sha"),
             }),
             base: Box::new(Base {
-                ref_field: "test".to_string(),
-                sha: "test".to_string(),
+                ref_field: "main".to_string(),
+                sha: "main-sha".to_string(),
             }),
         }
     }
 }
 
+impl Default for GitHubPullRequest {
+    fn default() -> Self {
+        Self::new(default_pr_number())
+    }
+}
+
 #[derive(Serialize)]
 struct Head {
     label: String,
diff --git a/src/tests/mocks/repository.rs b/src/tests/mocks/repository.rs
@@ -4,18 +4,18 @@ use crate::tests::event::default_pr_number;
 use base64::Engine;
 use serde::Serialize;
 use std::collections::HashMap;
+use tokio::sync::mpsc::Sender;
 use url::Url;
 use wiremock::{
     matchers::{method, path},
     Mock, MockServer, ResponseTemplate,
 };
 
+use crate::tests::mocks::comment::Comment;
+use crate::tests::mocks::pull_request::mock_pull_requests;
 use crate::tests::mocks::{Permissions, World};
 
-use super::{
-    pull_request::PullRequestsHandler,
-    user::{GitHubUser, User},
-};
+use super::user::{GitHubUser, User};
 
 #[derive(Clone)]
 pub struct Repo {
@@ -68,50 +68,46 @@ fn default_repo_name() -> GithubRepoName {
     GithubRepoName::new("rust-lang", "borstest")
 }
 
-/// Handles all repositories related requests
-#[derive(Default)]
-pub struct RepositoriesHandler;
-
-impl RepositoriesHandler {
-    pub async fn mount(&self, world: &World, mock_server: &MockServer) {
-        let repos = GitHubRepositories {
-            total_count: world.repos.len() as u64,
-            repositories: world
-                .repos
-                .iter()
-                .enumerate()
-                .map(|(index, (_, repo))| GitHubRepository {
-                    id: index as u64,
-                    owner: User::new(index as u64, repo.name.owner()).into(),
-                    name: repo.name.name().to_string(),
-                    url: format!("https://{}.foo", repo.name.name()).parse().unwrap(),
-                })
-                .collect(),
-        };
-
-        Mock::given(method("GET"))
-            .and(path("/installation/repositories"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(repos))
-            .mount(mock_server)
-            .await;
-
-        for repo in world.repos.values() {
-            PullRequestsHandler::new(repo.to_owned())
-                .mount(mock_server)
-                .await;
-            Mock::given(method("GET"))
-                .and(path(format!(
-                    "/repos/{}/contents/rust-bors.toml",
-                    repo.name
-                )))
-                .respond_with(
-                    ResponseTemplate::new(200)
-                        .set_body_json(GitHubContent::new("rust-bors.toml", &repo.config)),
-                )
-                .mount(mock_server)
-                .await;
-        }
-    }
+pub async fn mock_repo_list(world: &World, mock_server: &MockServer) {
+    let repos = GitHubRepositories {
+        total_count: world.repos.len() as u64,
+        repositories: world
+            .repos
+            .iter()
+            .enumerate()
+            .map(|(index, (_, repo))| GitHubRepository {
+                id: index as u64,
+                owner: User::new(index as u64, repo.name.owner()).into(),
+                name: repo.name.name().to_string(),
+                url: format!("https://{}.foo", repo.name.name()).parse().unwrap(),
+            })
+            .collect(),
+    };
+
+    Mock::given(method("GET"))
+        .and(path("/installation/repositories"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(repos))
+        .mount(mock_server)
+        .await;
+}
+
+pub async fn mock_repo(repo: &Repo, comments_tx: Sender<Comment>, mock_server: &MockServer) {
+    mock_pull_requests(repo, mock_server).await;
+    mock_config(repo, mock_server).await;
+}
+
+async fn mock_config(repo: &Repo, mock_server: &MockServer) {
+    Mock::given(method("GET"))
+        .and(path(format!(
+            "/repos/{}/contents/rust-bors.toml",
+            repo.name
+        )))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .set_body_json(GitHubContent::new("rust-bors.toml", &repo.config)),
+        )
+        .mount(mock_server)
+        .await;
 }
 
 /// Represents all repositories for an installation
