Reorganize files with messages in forge (#3834)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #

## Introduced changes

<!-- A brief description of the changes -->

-

## Checklist

<!-- Make sure all of these are complete -->

- [ ] Linked relevant issue
- [ ] Updated relevant documentation
- [ ] Added relevant tests
- [ ] Performed self-review of the code
- [ ] Added changes to `CHANGELOG.md`

Author: franciszekjob

crates/forge-runner/src/lib.rs

@@ -33,6 +33,7 @@ pub mod package_tests;
 pub mod profiler_api;
 pub mod test_case_summary;
 pub mod test_target_summary;
+pub mod tests_summary;
 
 pub mod backtrace;
 pub mod debugging;

crates/forge-runner/src/tests_summary.rs

@@ -0,0 +1,51 @@
+use crate::test_target_summary::TestTargetSummary;
+use serde::Serialize;
+
+// TODO(#2574): Bring back "filtered out" number in tests summary when running with `--exact` flag
+#[derive(Serialize)]
+pub struct TestsSummary {
+    passed: usize,
+    failed: usize,
+    interrupted: usize,
+    ignored: usize,
+    filtered: Option<usize>,
+}
+
+impl TestsSummary {
+    #[must_use]
+    pub fn new(summaries: &[TestTargetSummary], filtered: Option<usize>) -> Self {
+        let passed = summaries.iter().map(TestTargetSummary::count_passed).sum();
+        let failed = summaries.iter().map(TestTargetSummary::count_failed).sum();
+        let interrupted = summaries
+            .iter()
+            .map(TestTargetSummary::count_interrupted)
+            .sum();
+        let ignored = summaries.iter().map(TestTargetSummary::count_ignored).sum();
+
+        Self {
+            passed,
+            failed,
+            interrupted,
+            ignored,
+            filtered,
+        }
+    }
+
+    #[must_use]
+    pub fn format_summary_message(&self) -> String {
+        let filtered = self
+            .filtered
+            .map_or_else(|| "other".to_string(), |v| v.to_string());
+
+        let interrupted = if self.interrupted > 0 {
+            format!("\nInterrupted execution of {} test(s).", self.interrupted)
+        } else {
+            String::new()
+        };
+
+        format!(
+            "{} passed, {} failed, {} ignored, {filtered} filtered out{interrupted}",
+            self.passed, self.failed, self.ignored,
+        )
+    }
+}

crates/forge/src/run_tests.rs

@@ -1,6 +1,6 @@
 pub mod maat;
+pub mod messages;
 pub mod package;
 pub mod resolve_config;
-pub mod structs;
 pub mod test_target;
 pub mod workspace;

crates/forge/src/run_tests/messages/collected_tests_count.rs

@@ -0,0 +1,24 @@
+use console::style;
+use foundry_ui::Message;
+use serde::Serialize;
+use serde_json::{Value, json};
+
+#[derive(Serialize)]
+pub struct CollectedTestsCountMessage {
+    pub tests_num: usize,
+    pub package_name: String,
+}
+
+impl Message for CollectedTestsCountMessage {
+    fn text(&self) -> String {
+        let full = format!(
+            "\n\nCollected {} test(s) from {} package",
+            self.tests_num, self.package_name
+        );
+        style(full).bold().to_string()
+    }
+
+    fn json(&self) -> Value {
+        json!(self)
+    }
+}

crates/forge/src/run_tests/messages/latest_blocks_numbers.rs

@@ -0,0 +1,40 @@
+use foundry_ui::Message;
+use serde::Serialize;
+use serde_json::{Value, json};
+use std::{collections::HashMap, fmt::Write};
+
+#[derive(Serialize)]
+pub struct LatestBlocksNumbersMessage {
+    url_to_latest_block_number_map: HashMap<url::Url, starknet_api::block::BlockNumber>,
+}
+
+impl LatestBlocksNumbersMessage {
+    #[must_use]
+    pub fn new(
+        url_to_latest_block_number_map: HashMap<url::Url, starknet_api::block::BlockNumber>,
+    ) -> Self {
+        Self {
+            url_to_latest_block_number_map,
+        }
+    }
+}
+
+impl Message for LatestBlocksNumbersMessage {
+    fn text(&self) -> String {
+        let mut output = String::new();
+        output = format!("{output}\n");
+
+        for (url, latest_block_number) in &self.url_to_latest_block_number_map {
+            let _ = writeln!(
+                &mut output,
+                "Latest block number = {latest_block_number} for url = {url}"
+            );
+        }
+
+        output
+    }
+
+    fn json(&self) -> Value {
+        json!(self)
+    }
+}

crates/forge/src/run_tests/messages/mod.rs

@@ -0,0 +1,6 @@
+pub mod collected_tests_count;
+pub mod latest_blocks_numbers;
+pub mod overall_summary;
+pub mod tests_failure_summary;
+pub mod tests_run;
+pub mod tests_summary;

crates/forge/src/run_tests/messages/overall_summary.rs

@@ -0,0 +1,33 @@
+use console::style;
+use forge_runner::test_target_summary::TestTargetSummary;
+use forge_runner::tests_summary::TestsSummary;
+use foundry_ui::{Message, components::labeled::LabeledMessage};
+use serde::Serialize;
+use serde_json::{Value, json};
+
+#[derive(Serialize)]
+pub struct OverallSummaryMessage {
+    summary: TestsSummary,
+}
+
+impl OverallSummaryMessage {
+    pub const LABEL: &str = "Tests summary";
+
+    #[must_use]
+    pub fn new(summaries: &[TestTargetSummary], filtered: Option<usize>) -> Self {
+        Self {
+            summary: TestsSummary::new(summaries, filtered),
+        }
+    }
+}
+
+impl Message for OverallSummaryMessage {
+    fn text(&self) -> String {
+        let styled_label = style(&Self::LABEL).bold().to_string();
+        LabeledMessage::new(&styled_label, &self.summary.format_summary_message()).text()
+    }
+
+    fn json(&self) -> Value {
+        json!(self)
+    }
+}

crates/forge/src/run_tests/messages/tests_failure_summary.rs

@@ -0,0 +1,41 @@
+use console::style;
+use forge_runner::test_case_summary::AnyTestCaseSummary;
+use foundry_ui::Message;
+use serde::Serialize;
+use serde_json::{Value, json};
+use std::fmt::Write;
+
+#[derive(Serialize)]
+pub struct TestsFailureSummaryMessage {
+    pub failed_test_names: Vec<String>,
+}
+
+impl TestsFailureSummaryMessage {
+    #[must_use]
+    pub fn new(all_failed_tests: &[AnyTestCaseSummary]) -> Self {
+        let failed_test_names = all_failed_tests
+            .iter()
+            .map(|any_test_case_summary| any_test_case_summary.name().unwrap().to_string())
+            .collect();
+
+        Self { failed_test_names }
+    }
+}
+
+impl Message for TestsFailureSummaryMessage {
+    fn text(&self) -> String {
+        if self.failed_test_names.is_empty() {
+            return String::new();
+        }
+
+        let mut failures = "\nFailures:".to_string();
+        for name in &self.failed_test_names {
+            let _ = write!(&mut failures, "\n    {name}");
+        }
+        style(failures).bold().to_string()
+    }
+
+    fn json(&self) -> Value {
+        json!(self)
+    }
+}

crates/forge/src/run_tests/messages/tests_run.rs

@@ -0,0 +1,36 @@
+use console::style;
+use forge_runner::package_tests::TestTargetLocation;
+use foundry_ui::Message;
+use serde::Serialize;
+use serde_json::{Value, json};
+
+#[derive(Serialize)]
+pub struct TestsRunMessage {
+    test_target_location: TestTargetLocation,
+    tests_num: usize,
+}
+
+impl TestsRunMessage {
+    #[must_use]
+    pub fn new(test_target_location: TestTargetLocation, tests_num: usize) -> Self {
+        Self {
+            test_target_location,
+            tests_num,
+        }
+    }
+}
+
+impl Message for TestsRunMessage {
+    fn text(&self) -> String {
+        let dir_name = match self.test_target_location {
+            TestTargetLocation::Lib => "src",
+            TestTargetLocation::Tests => "tests",
+        };
+        let plain_text = format!("Running {} test(s) from {}/", self.tests_num, dir_name);
+        style(plain_text).bold().to_string()
+    }
+
+    fn json(&self) -> Value {
+        json!(self)
+    }
+}

crates/forge/src/run_tests/messages/tests_summary.rs

@@ -0,0 +1,32 @@
+use console::style;
+use forge_runner::{test_target_summary::TestTargetSummary, tests_summary::TestsSummary};
+use foundry_ui::{Message, components::labeled::LabeledMessage};
+use serde::Serialize;
+use serde_json::{Value, json};
+
+#[derive(Serialize)]
+pub struct TestsSummaryMessage {
+    summary: TestsSummary,
+}
+
+impl TestsSummaryMessage {
+    pub const LABEL: &str = "Tests";
+
+    #[must_use]
+    pub fn new(summaries: &[TestTargetSummary], filtered: Option<usize>) -> Self {
+        Self {
+            summary: TestsSummary::new(summaries, filtered),
+        }
+    }
+}
+
+impl Message for TestsSummaryMessage {
+    fn text(&self) -> String {
+        let styled_label = style(&Self::LABEL).bold().to_string();
+        LabeledMessage::new(&styled_label, &self.summary.format_summary_message()).text()
+    }
+
+    fn json(&self) -> Value {
+        json!(self)
+    }
+}