Support #[itest(focus)]

Author: Bromeon

godot-macros/src/itest.rs

@@ -52,6 +52,7 @@ pub fn transform(input_decl: Declaration) -> ParseResult<TokenStream> {
         ::godot::sys::plugin_add!(__GODOT_ITEST in crate; crate::RustTestCase {
             name: #test_name_str,
             skipped: #skipped,
+            focused: #focused,
             file: std::file!(),
             line: std::line!(),
             function: #test_name,

itest/rust/src/lib.rs

@@ -61,26 +61,39 @@ unsafe impl ExtensionLibrary for runner::IntegrationTests {}
 sys::plugin_registry!(__GODOT_ITEST: RustTestCase);
 
 /// Finds all `#[itest]` tests.
-fn collect_rust_tests() -> (Vec<RustTestCase>, usize) {
+fn collect_rust_tests() -> (Vec<RustTestCase>, usize, bool) {
     let mut all_files = std::collections::HashSet::new();
     let mut tests: Vec<RustTestCase> = vec![];
+    let mut is_focus_run = false;
 
     sys::plugin_foreach!(__GODOT_ITEST; |test: &RustTestCase| {
-        all_files.insert(test.file);
-        tests.push(*test);
+        // First time a focused test is encountered, switch to "focused" mode and throw everything away.
+        if !is_focus_run && test.focused {
+            tests.clear();
+            all_files.clear();
+            is_focus_run = true;
+        }
+
+        // Only collect tests if normal mode, or focus mode and test is focused.
+        if !is_focus_run || test.focused {
+            all_files.insert(test.file);
+            tests.push(*test);
+        }
     });
 
     // Sort alphabetically for deterministic run order
     tests.sort_by_key(|test| test.file);
 
-    (tests, all_files.len())
+    (tests, all_files.len(), is_focus_run)
 }
 
 #[derive(Copy, Clone)]
 struct RustTestCase {
     name: &'static str,
     file: &'static str,
     skipped: bool,
+    /// If one or more tests are focused, only they will be executed. Helpful for debugging and working on specific features.
+    focused: bool,
     #[allow(dead_code)]
     line: u32,
     function: fn(),

itest/rust/src/runner.rs

@@ -16,6 +16,7 @@ pub(crate) struct IntegrationTests {
     total: i64,
     passed: i64,
     skipped: i64,
+    focus_run: bool,
 }
 
 #[godot_api]
@@ -28,23 +29,33 @@ impl IntegrationTests {
             FMT_GREEN_BOLD, FMT_END
         );
 
-        let (rust_tests, rust_file_count) = super::collect_rust_tests();
+        let (rust_tests, rust_file_count, focus_run) = super::collect_rust_tests();
+        self.focus_run = focus_run;
+        if focus_run {
+            println!("  Focused run -- execute only selected Rust tests.")
+        }
         println!(
             "  Rust: found {} tests in {} files.",
             rust_tests.len(),
             rust_file_count
         );
-        println!(
-            "  GDScript: found {} tests in {} files.",
-            gdscript_tests.len(),
-            gdscript_file_count
-        );
+        if !focus_run {
+            println!(
+                "  GDScript: found {} tests in {} files.",
+                gdscript_tests.len(),
+                gdscript_file_count
+            );
+        }
 
         let clock = Instant::now();
         self.run_rust_tests(rust_tests);
         let rust_time = clock.elapsed();
-        self.run_gdscript_tests(gdscript_tests);
-        let gdscript_time = clock.elapsed() - rust_time;
+        let gdscript_time = if !focus_run {
+            self.run_gdscript_tests(gdscript_tests);
+            Some(clock.elapsed() - rust_time)
+        } else {
+            None
+        };
 
         self.conclude(rust_time, gdscript_time)
     }
@@ -76,7 +87,7 @@ impl IntegrationTests {
         }
     }
 
-    fn conclude(&self, rust_time: Duration, gdscript_time: Duration) -> bool {
+    fn conclude(&self, rust_time: Duration, gdscript_time: Option<Duration>) -> bool {
         let Self {
             total,
             passed,
@@ -91,17 +102,25 @@ impl IntegrationTests {
         let outcome = TestOutcome::from_bool(all_passed);
 
         let rust_time = rust_time.as_secs_f32();
-        let gdscript_time = gdscript_time.as_secs_f32();
-        let total_time = rust_time + gdscript_time;
+        let gdscript_time = gdscript_time.map(|t| t.as_secs_f32());
 
         let extra = if skipped > 0 {
             format!(", {skipped} skipped")
+        } else if gdscript_time.is_none() {
+            " (focused run)".to_string()
         } else {
             "".to_string()
         };
 
         println!("\nTest result: {outcome}. {passed} passed; {failed} failed{extra}.");
-        println!("  Time: {total_time:.2}s.  (Rust {rust_time:.2}s, GDScript {gdscript_time:.2}s)");
+        if let Some(gdscript_time) = gdscript_time {
+            let total_time = rust_time + gdscript_time;
+            println!(
+                "  Time: {total_time:.2}s.  (Rust {rust_time:.2}s, GDScript {gdscript_time:.2}s)"
+            );
+        } else {
+            println!("  Time: {rust_time:.2}s.");
+        }
         all_passed
     }