init

Author: gnalh

Diff for: Cargo.lock

@@ -184,6 +184,41 @@ 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())
+            },
+        }
+        .call_api()
+        .await
+    }
+
     pub async fn put_bundle_to_s3<U: AsRef<str>, B: AsRef<Path>>(
         &self,
         url: U,

Diff for: api/src/client.rs

@@ -63,3 +63,56 @@ pub struct CreateBundleUploadIntentResponse {
 pub struct TelemetryUploadMetricsRequest {
     pub upload_metrics: proto::upload_metrics::trunk::UploadMetrics,
 }
+
+#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
+pub struct PageQuery {
+    #[serde(rename = "pageSize")]
+    pub page_size: i32,
+    #[serde(rename = "pageToken")]
+    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,
+    #[serde(rename = "orgUrlSlug")]
+    pub org_url_slug: String,
+    #[serde(rename = "pageQuery")]
+    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>,
+    #[serde(rename = "className")]
+    pub class_name: 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,
+}

Diff for: api/src/message.rs

@@ -22,6 +22,7 @@ pub struct Test {
     pub id: String,
     /// Added in v0.6.9
     pub timestamp_millis: Option<i64>,
+    pub is_quarantined: bool,
 }
 
 impl Test {
@@ -41,6 +42,7 @@ impl Test {
             file,
             id: String::with_capacity(0),
             timestamp_millis,
+            is_quarantined: false,
         };
 
         test.set_id(org_slug, repo);

Diff for: bundle/src/types.rs

@@ -19,7 +19,7 @@ bundle = { path = "../bundle" }
 constants = { path = "../constants" }
 chrono = { version = "0.4.33", default-features = false, features = ["clock"] }
 clap = { version = "4.4.18", features = ["derive", "env"] }
-context = { path = "../context" }
+context = { path = "../context", features = ["bindings"] }
 third-party = { path = "../third-party" }
 env_logger = { version = "0.11.0", default-features = false }
 log = "0.4.14"
@@ -54,6 +54,7 @@ proto = { path = "../proto" }
 regex = "1.11.1"
 lazy_static = "1.5.0"
 url = "2.5.4"
+prost = "0.12.6"
 
 [dev-dependencies]
 test_utils = { version = "0.1.0", path = "../test_utils" }

Diff for: cli/Cargo.toml

@@ -1,13 +1,22 @@
-use std::collections::HashMap;
+use std::{
+    collections::HashMap,
+    io::{BufReader, Read},
+};
 
 use api::{client::ApiClient, urls::url_for_test_case};
-use bundle::{FileSet, FileSetBuilder, QuarantineBulkTestStatus, Test};
+use bundle::{FileSet, FileSetBuilder, FileSetType, QuarantineBulkTestStatus, Test};
 use constants::{EXIT_FAILURE, EXIT_SUCCESS};
 use context::{
-    junit::{junit_path::JunitReportStatus, parser::JunitParser},
+    junit::{
+        bindings::{
+            BindingsReport, BindingsTestCase, BindingsTestCaseStatusStatus, BindingsTestSuite,
+        },
+        junit_path::JunitReportStatus,
+        parser::JunitParser,
+    },
     repo::RepoUrlParts,
 };
-use quick_junit::TestCaseStatus;
+use prost::Message;
 
 use crate::error_report::{log_error, Context};
 
@@ -21,27 +30,28 @@ fn convert_case_to_test<T: AsRef<str>>(
     repo: &RepoUrlParts,
     org_slug: T,
     parent_name: String,
-    case: &quick_junit::TestCase,
-    suite: &quick_junit::TestSuite,
+    case: &BindingsTestCase,
+    suite: &BindingsTestSuite,
 ) -> Test {
     let name = String::from(case.name.as_str());
-    let xml_string_to_string = |s: &quick_junit::XmlString| String::from(s.as_str());
-    let class_name = case.classname.as_ref().map(xml_string_to_string);
-    let file = case.extra.get("file").map(xml_string_to_string);
-    let timestamp_millis = case
-        .timestamp
-        .or(suite.timestamp)
-        .map(|t| t.timestamp_millis());
+    let class_name = case.classname.clone();
+    let file = case.extra().get("file").cloned();
+    let timestamp_millis = case.timestamp.or(suite.timestamp);
     let mut test = Test {
         name,
         parent_name,
         class_name,
         file,
         id: String::with_capacity(0),
         timestamp_millis,
+        is_quarantined: case.status.status == BindingsTestCaseStatusStatus::Quarantined,
     };
-    if let Some(id) = case.extra.get("id").map(xml_string_to_string) {
-        test.id = id;
+    if let Some(id) = case.extra().get("id") {
+        if id.is_empty() {
+            test.set_id(org_slug, repo);
+        } else {
+            test.id = id.clone();
+        }
     } else {
         test.set_id(org_slug, repo);
     }
@@ -65,39 +75,59 @@ impl FailedTestsExtractor {
                     continue;
                 }
             }
-            for file in &file_set.files {
-                let file = match std::fs::File::open(&file.original_path) {
+            for base_file in &file_set.files {
+                let file = match std::fs::File::open(&base_file.original_path) {
                     Ok(file) => file,
                     Err(e) => {
-                        tracing::warn!("Error opening file: {}", e);
                         continue;
                     }
                 };
-                let reader = std::io::BufReader::new(file);
-                let mut junitxml = JunitParser::new();
-                match junitxml.parse(reader) {
-                    Ok(junitxml) => junitxml,
-                    Err(e) => {
-                        tracing::warn!("Error parsing junitxml: {}", e);
+                let mut reader = BufReader::new(file);
+                // check if the extension ends with xml
+                let bindings_reports = if file_set.file_set_type == FileSetType::Junit {
+                    let mut junitxml = JunitParser::new();
+                    match junitxml.parse(reader) {
+                        Ok(junitxml) => junitxml,
+                        Err(e) => {
+                            continue;
+                        }
+                    };
+                    junitxml
+                        .into_reports()
+                        .iter()
+                        .map(|report| BindingsReport::from(report.clone()))
+                        .collect::<Vec<BindingsReport>>()
+                } else {
+                    // Create a vector to hold the contents
+                    let mut buffer = Vec::new();
+
+                    // Read all the bytes into the vector
+                    let result = reader.read_to_end(&mut buffer);
+                    if let Err(e) = result {
                         continue;
                     }
+                    let test_result =
+                        proto::test_context::test_run::TestResult::decode(buffer.as_slice())
+                            .unwrap();
+                    vec![BindingsReport::from(test_result)]
                 };
-                for report in junitxml.reports() {
-                    for suite in &report.test_suites {
+                for report in bindings_reports {
+                    for suite in report.test_suites {
                         let parent_name = String::from(suite.name.as_str());
                         for case in &suite.test_cases {
                             let test = convert_case_to_test(
                                 repo,
                                 org_slug.as_ref(),
                                 parent_name.clone(),
                                 case,
-                                suite,
+                                &suite,
                             );
-                            match &case.status {
-                                TestCaseStatus::Skipped { .. } => {
+                            match &case.status.status {
+                                BindingsTestCaseStatusStatus::Unspecified
+                                | BindingsTestCaseStatusStatus::Skipped { .. } => {
                                     continue;
                                 }
-                                TestCaseStatus::Success { .. } => {
+                                BindingsTestCaseStatusStatus::Success { .. } => {
                                     if let Some(existing_timestamp) = successes.get(&test.id) {
                                         if *existing_timestamp > test.timestamp_millis.unwrap_or(0)
                                         {
@@ -109,7 +139,8 @@ impl FailedTestsExtractor {
                                         test.timestamp_millis.unwrap_or(0),
                                     );
                                 }
-                                TestCaseStatus::NonSuccess { .. } => {
+                                BindingsTestCaseStatusStatus::Quarantined
+                                | BindingsTestCaseStatusStatus::NonSuccess { .. } => {
                                     // Only store the most recent failure of a given test run ID
                                     if let Some(existing_test) = failures.get(&test.id) {
                                         if existing_test.timestamp_millis > test.timestamp_millis {
@@ -179,7 +210,13 @@ pub async fn gather_quarantine_context(
         };
     }
 
-    let quarantine_config = if !failed_tests_extractor.failed_tests().is_empty() {
+    let quarantine_config = if !failed_tests_extractor.failed_tests().is_empty()
+        && file_set_builder
+            .file_sets()
+            .iter()
+            // internal files track quarantine status directly, so we don't need to check them
+            .any(|file_set| file_set.file_set_type == FileSetType::Junit)
+    {
         tracing::info!("Checking if failed tests can be quarantined");
         let result = api_client.get_quarantining_config(request).await;
 
@@ -195,7 +232,7 @@ pub async fn gather_quarantine_context(
 
         result.unwrap_or_default()
     } else {
-        tracing::debug!("No failed tests to quarantine");
+        tracing::debug!("Skipping quarantine check.");
         api::message::GetQuarantineConfigResponse::default()
     };
 
@@ -223,7 +260,7 @@ pub async fn gather_quarantine_context(
         .iter()
         .cloned()
         .for_each(|failure| {
-            let quarantine_failure = quarantined.contains(&failure.id);
+            let quarantine_failure = quarantined.contains(&failure.id) || failure.is_quarantined;
             if quarantine_failure {
                 quarantined_failures.push(failure);
             } else {