Use /getQuarantineConfig for rspec (#932)

Part of [TRUNK-17215](https://linear.app/trunk/issue/TRUNK-17215/cli-validate-rspec-api-lifetime-cache-calls)

Swaps usage of `/list-quarantined-tests` with `/getQuarantineConfig` for rspec, to avoid repeated paginated calls and get all quarantined test IDs in one round trip

Tested locally using a gem built with these changes:

<details><summary>local rspec invocation output</summary>

```
bundle exec rspec

Randomized with seed 51378

Main
  .always_true
    always passes
  .coin_flip
Test failed, checking if it can be quarantined: `./spec/main_spec.rb:12`
Test is not quarantined, continuing
    sometimes passes (FAILED - 1)
  .always_true
Test failed, checking if it can be quarantined: `./spec/main_spec.rb:18`
Test is quarantined, overriding exception: 
expected false
     got true

    always fails

Failures:

  1) Main.coin_flip sometimes passes
     Failure/Error: expect(Main.coin_flip).to be true
     
       expected true
            got false
     # ./spec/main_spec.rb:13:in `block (3 levels) in <top (required)>'
     # ./gems/rspec_trunk_flaky_tests/lib/trunk_spec_helper.rb:147:in `run'
     # ./gems/rspec_trunk_flaky_tests/lib/trunk_spec_helper.rb:117:in `run_with_trunk'

Top 3 slowest examples (0.4614 seconds, 99.4% of total time):
  Main.coin_flip sometimes passes
    0.45776 seconds ./spec/main_spec.rb:12
  Main.always_true always fails
    0.00338 seconds ./spec/main_spec.rb:18
  Main.always_true always passes
    0.00025 seconds ./spec/main_spec.rb:6

Finished in 0.46415 seconds (files took 0.04015 seconds to load)
3 examples, 1 failure

Failed examples:

rspec ./spec/main_spec.rb:12 # Main.coin_flip sometimes passes

Randomized with seed 51378
Flaky tests report upload complete
```

</details>

Author: max-trunk

api/src/client.rs

@@ -3,8 +3,8 @@ use std::sync::mpsc::Sender;
 
 use constants::{DEFAULT_ORIGIN, TRUNK_PUBLIC_API_ADDRESS_ENV};
 use display::message::DisplayMessage;
-use http::{header::HeaderMap, HeaderValue};
-use reqwest::{header, Client, Response, StatusCode};
+use http::{HeaderValue, header::HeaderMap};
+use reqwest::{Client, Response, StatusCode, header};
 use serde::de::DeserializeOwned;
 use tokio::fs;
 
@@ -194,42 +194,6 @@ impl ApiClient {
         .await
     }
 
-    pub async fn list_quarantined_tests(
-        &self,
-        request: &message::ListQuarantinedTestsRequest,
-    ) -> anyhow::Result<message::ListQuarantinedTestsResponse> {
-        CallApi {
-            action: || async {
-                let response = self
-                    .trunk_api_client
-                    .post(format!("{}{}/flaky-tests/list-quarantined-tests", self.api_host, self.version_path_prefix))
-                    .json(&request)
-                    .send()
-                    .await?;
-
-                let response = status_code_help(
-                    response,
-                    CheckUnauthorized::Check,
-                    CheckNotFound::DoNotCheck,
-                    |_| String::from("Failed to list quarantined tests."),
-                    &self.api_host,
-                    &self.org_url_slug,
-                )?;
-
-                self.deserialize_response::<message::ListQuarantinedTestsResponse>(response).await
-            },
-            log_progress_message: |time_elapsed, _| {
-                format!("Listing quarantined tests from Trunk services is taking longer than expected. It has taken {} seconds so far.", time_elapsed.as_secs())
-            },
-            report_slow_progress_message: |time_elapsed| {
-                format!("Listing quarantined tests from Trunk services is taking longer than {} seconds", time_elapsed.as_secs())
-            },
-            render_sender: self.render_sender.clone(),
-        }
-        .call_api()
-        .await
-    }
-
     pub async fn put_bundle_to_s3<U: AsRef<str>, B: AsRef<Path>>(
         &self,
         url: U,
@@ -450,8 +414,8 @@ fn does_not_add_settings_if_domain_absent() {
 #[cfg(test)]
 mod tests {
     use std::sync::{
-        atomic::{AtomicUsize, Ordering},
         Arc,
+        atomic::{AtomicUsize, Ordering},
     };
 
     use axum::{http::StatusCode, response::Response};
@@ -488,21 +452,23 @@ mod tests {
             ApiClient::new(String::from("mock-token"), String::from("mock-org"), None).unwrap();
         api_client.api_host.clone_from(&state.host);
 
-        assert!(api_client
-            .get_quarantining_config(&message::GetQuarantineConfigRequest {
-                repo: context::repo::RepoUrlParts {
-                    host: String::from("host"),
-                    owner: String::from("owner"),
-                    name: String::from("name"),
-                },
-                org_url_slug: String::from("org_url_slug"),
-                test_identifiers: vec![],
-                remote_urls: vec![],
-            })
-            .await
-            .unwrap_err()
-            .to_string()
-            .contains("501 Not Implemented"));
+        assert!(
+            api_client
+                .get_quarantining_config(&message::GetQuarantineConfigRequest {
+                    repo: context::repo::RepoUrlParts {
+                        host: String::from("host"),
+                        owner: String::from("owner"),
+                        name: String::from("name"),
+                    },
+                    org_url_slug: String::from("org_url_slug"),
+                    test_identifiers: vec![],
+                    remote_urls: vec![],
+                })
+                .await
+                .unwrap_err()
+                .to_string()
+                .contains("501 Not Implemented")
+        );
         assert_eq!(CALL_COUNT.load(Ordering::Relaxed), 1);
     }
 
@@ -532,21 +498,23 @@ mod tests {
             ApiClient::new(String::from("mock-token"), String::from("mock-org"), None).unwrap();
         api_client.api_host.clone_from(&state.host);
 
-        assert!(api_client
-            .get_quarantining_config(&message::GetQuarantineConfigRequest {
-                repo: context::repo::RepoUrlParts {
-                    host: String::from("api_host"),
-                    owner: String::from("owner"),
-                    name: String::from("name"),
-                },
-                remote_urls: vec![],
-                org_url_slug: String::from("org_url_slug"),
-                test_identifiers: vec![],
-            })
-            .await
-            .unwrap_err()
-            .to_string()
-            .contains("500 Internal Server Error"));
+        assert!(
+            api_client
+                .get_quarantining_config(&message::GetQuarantineConfigRequest {
+                    repo: context::repo::RepoUrlParts {
+                        host: String::from("api_host"),
+                        owner: String::from("owner"),
+                        name: String::from("name"),
+                    },
+                    remote_urls: vec![],
+                    org_url_slug: String::from("org_url_slug"),
+                    test_identifiers: vec![],
+                })
+                .await
+                .unwrap_err()
+                .to_string()
+                .contains("500 Internal Server Error")
+        );
         assert_eq!(CALL_COUNT.load(Ordering::Relaxed), 6);
     }
 
@@ -571,20 +539,22 @@ mod tests {
             ApiClient::new(String::from("mock-token"), String::from("mock-org"), None).unwrap();
         api_client.api_host.clone_from(&state.host);
 
-        assert!(api_client
-            .get_quarantining_config(&message::GetQuarantineConfigRequest {
-                repo: context::repo::RepoUrlParts {
-                    host: String::from("api_host"),
-                    owner: String::from("owner"),
-                    name: String::from("name"),
-                },
-                remote_urls: vec![],
-                org_url_slug: String::from("org_url_slug"),
-                test_identifiers: vec![],
-            })
-            .await
-            .unwrap_err()
-            .to_string()
-            .contains("404 Not Found"));
+        assert!(
+            api_client
+                .get_quarantining_config(&message::GetQuarantineConfigRequest {
+                    repo: context::repo::RepoUrlParts {
+                        host: String::from("api_host"),
+                        owner: String::from("owner"),
+                        name: String::from("name"),
+                    },
+                    remote_urls: vec![],
+                    org_url_slug: String::from("org_url_slug"),
+                    test_identifiers: vec![],
+                })
+                .await
+                .unwrap_err()
+                .to_string()
+                .contains("404 Not Found")
+        );
     }
 }

api/src/message.rs

@@ -65,51 +65,3 @@ pub struct CreateBundleUploadIntentResponse {
 pub struct TelemetryUploadMetricsRequest {
     pub upload_metrics: proto::upload_metrics::trunk::UploadMetrics,
 }
-
-#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
-pub struct PageQuery {
-    pub page_size: i32,
-    pub page_token: String,
-}
-
-#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
-pub struct Page {
-    pub total_rows: i32,
-    pub total_pages: i32,
-    pub next_page_token: String,
-    pub prev_page_token: String,
-    pub last_page_token: String,
-    pub page_index: i32,
-}
-
-#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
-pub struct ListQuarantinedTestsRequest {
-    pub repo: RepoUrlParts,
-    pub org_url_slug: String,
-    pub page_query: PageQuery,
-}
-
-#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
-pub enum QuarantineSetting {
-    #[serde(rename = "ALWAYS_QUARANTINE")]
-    AlwaysQuarantine,
-    #[serde(rename = "AUTO_QUARANTINE")]
-    AutoQuarantine,
-}
-
-#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
-pub struct QuarantinedTest {
-    pub name: String,
-    pub parent: Option<String>,
-    pub file: Option<String>,
-    pub classname: Option<String>,
-    pub status: String,
-    pub quarantine_setting: QuarantineSetting,
-    pub test_case_id: String,
-}
-
-#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
-pub struct ListQuarantinedTestsResponse {
-    pub quarantined_tests: Vec<QuarantinedTest>,
-    pub page: Page,
-}

cli-tests/src/upload.rs

@@ -65,7 +65,7 @@ async fn upload_bundle() {
 
     let quarantine_request = requests_iter.next().unwrap();
     let mut failure_count = 0;
-    assert_matches!(quarantine_request, RequestPayload::GetQuarantineBulkTestStatus(req) => {
+    assert_matches!(quarantine_request, RequestPayload::GetQuarantineConfig(req) => {
         assert_eq!(req.repo.host, "github.com");
         assert_eq!(req.repo.owner, "trunk-io");
         assert_eq!(req.repo.name, "analytics-cli");
@@ -1192,7 +1192,7 @@ async fn test_variant_propagation() {
 
     assert_matches!(
         requests_iter.next().unwrap(),
-        RequestPayload::GetQuarantineBulkTestStatus(_)
+        RequestPayload::GetQuarantineConfig(_)
     );
 
     assert_matches!(

test_report/src/report.rs

@@ -13,7 +13,7 @@ use chrono::prelude::*;
 use codeowners::CodeOwners;
 use context::repo::{BundleRepo, RepoUrlParts};
 #[cfg(feature = "ruby")]
-use magnus::{value::ReprValue, Module, Object};
+use magnus::{Module, Object, value::ReprValue};
 use prost_wkt_types::Timestamp;
 use proto::test_context::test_run::{
     CodeOwner, TestCaseRun, TestCaseRunStatus, TestReport as TestReportProto, TestResult,
@@ -280,7 +280,12 @@ impl MutTestReport {
                     None,
                     variant.clone(),
                 );
-                self.populate_quarantined_tests(&api_client, &bundle_repo.repo, org_url_slug);
+                self.populate_quarantined_tests(
+                    &api_client,
+                    &bundle_repo.repo,
+                    bundle_repo.repo_url,
+                    org_url_slug,
+                );
                 if let Some(quarantined_tests) = self.0.borrow().quarantined_tests.as_ref() {
                     return quarantined_tests.get(&test_identifier.id).is_some();
                 }
@@ -297,47 +302,39 @@ impl MutTestReport {
         &self,
         api_client: &ApiClient,
         repo: &RepoUrlParts,
+        repo_url: String,
         org_url_slug: String,
     ) {
         if self.0.borrow().quarantined_tests.as_ref().is_some() {
             // already fetched
             return;
         }
         let mut quarantined_tests = HashMap::new();
-        let mut request = message::ListQuarantinedTestsRequest {
-            org_url_slug: org_url_slug.clone(),
-            page_query: message::PageQuery {
-                page_size: 100,
-                page_token: String::new(),
-            },
+        let request = message::GetQuarantineConfigRequest {
+            org_url_slug,
+            test_identifiers: vec![],
+            remote_urls: vec![repo_url],
             repo: repo.clone(),
         };
-        loop {
-            let response = tokio::runtime::Builder::new_multi_thread()
-                .enable_all()
-                .build()
-                .unwrap()
-                .block_on(api_client.list_quarantined_tests(&request));
-            match response {
-                Ok(response) => {
-                    for test in response.quarantined_tests.iter() {
-                        quarantined_tests.insert(test.test_case_id.clone(), true);
-                    }
-                    if response.page.next_page_token.is_empty() {
-                        break;
-                    }
-                    request.page_query.page_token = response.page.next_page_token;
-                }
-                Err(err) => {
-                    tracing::warn!("Unable to fetch quarantined tests");
-                    tracing::error!(
-                        hidden_in_console = true,
-                        "Error fetching quarantined tests: {:?}",
-                        err
-                    );
-                    break;
+        let response = tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .unwrap()
+            .block_on(api_client.get_quarantining_config(&request));
+        match response {
+            Ok(response) => {
+                for quarantined_test_id in response.quarantined_tests.iter() {
+                    quarantined_tests.insert(quarantined_test_id.clone(), true);
                 }
             }
+            Err(err) => {
+                tracing::warn!("Unable to fetch quarantined tests");
+                tracing::error!(
+                    hidden_in_console = true,
+                    "Error fetching quarantined tests: {:?}",
+                    err
+                );
+            }
         }
         self.0.borrow_mut().quarantined_tests = Some(quarantined_tests);
     }