Sort test execution order by change status and transitive dependency count for better test prioritization.

Author: aevyrie

src/commands/check_workspace/mod.rs

@@ -1246,12 +1246,12 @@ impl<'a, C: CrateChecker> WorkspaceChecker<'a, C> {
             // Check changed from a git pov
             let changed_package_paths =
                 crates.changed_packages(&repo, base_commit_id, head_commit_id, &diff_strategy)?;
-            tracing::info!("Changed packages: {changed_package_paths:#?}");
+            tracing::debug!("Changed packages: {changed_package_paths:#?}");
             // Any packages that transitively depend on changed packages are also considered "changed".
             let changed_closure = crates
                 .default_dependency_graph()
                 .reverse_closure(changed_package_paths.iter().map(AsRef::as_ref));
-            tracing::info!("Changed closure: {changed_closure:#?}");
+            tracing::debug!("Changed closure: {changed_closure:#?}");
 
             for package_key in package_keys.clone() {
                 if let Some(ref pb) = pb {

src/commands/tests/mod.rs

@@ -287,9 +287,110 @@ pub async fn tests(
     let semaphore = Arc::new(Semaphore::new(common_options.job_limit));
     let mut handles = vec![];
 
-    for (_, member) in results.members.into_iter().filter(|(_, member)| {
-        !member.test_detail.skip.unwrap_or_default() && (member.perform_test || options.run_all)
-    }) {
+    // Precompute transitive dependency counts for sorting and display.
+    let dep_graph = results.crate_graph.dependency_graph();
+    let transitive_dep_counts: HashMap<String, usize> = results
+        .members
+        .values()
+        .filter_map(|m| {
+            m.package_id.as_ref().map(|id| {
+                (
+                    m.package.clone(),
+                    dep_graph.get_transitive_dependencies(id.clone()).len(),
+                )
+            })
+        })
+        .collect();
+
+    // Sort members so directly changed crates run first (fail fast), then
+    // dependency-changed, then unchanged (only present with --run-all).
+    // Within each group, crates with more transitive dependencies run first
+    // (higher in the tree, more likely to surface issues), then alphabetically.
+    let mut members: Vec<_> = results
+        .members
+        .into_values()
+        .filter(|member| {
+            !member.test_detail.skip.unwrap_or_default() && (member.perform_test || options.run_all)
+        })
+        .collect();
+    members.sort_by(|a, b| {
+        let a_deps = transitive_dep_counts.get(&a.package).copied().unwrap_or(0);
+        let b_deps = transitive_dep_counts.get(&b.package).copied().unwrap_or(0);
+        b.changed
+            .cmp(&a.changed)
+            .then(b.dependencies_changed.cmp(&a.dependencies_changed))
+            .then(b_deps.cmp(&a_deps))
+            .then(a.package.cmp(&b.package))
+    });
+
+    // Print execution order grouped by change status.
+    {
+        let name_w = members
+            .iter()
+            .map(|m| m.package.len())
+            .max()
+            .unwrap_or(7)
+            .max(7);
+        let deps_w = 4; // "Deps" header
+        #[expect(clippy::type_complexity)]
+        let groups: &[(&str, Box<dyn Fn(&super::check_workspace::Result) -> bool>)] = &[
+            ("Directly changed", Box::new(|m| m.changed)),
+            (
+                "Dependency changed",
+                Box::new(|m| !m.changed && m.dependencies_changed),
+            ),
+            (
+                "Unchanged",
+                Box::new(|m| !m.changed && !m.dependencies_changed),
+            ),
+        ];
+        let active_groups: Vec<_> = groups
+            .iter()
+            .filter_map(|(label, pred)| {
+                let rows: Vec<_> = members.iter().filter(|m| pred(m)).collect();
+                if rows.is_empty() {
+                    None
+                } else {
+                    Some((*label, rows))
+                }
+            })
+            .collect();
+        if !active_groups.is_empty() {
+            // Column widths including padding: " content "
+            let nc = name_w + 2; // name column cell width
+            let dc = deps_w + 2; // deps column cell width
+            // Total width between outer box chars: nc + 1(│) + dc
+            let total = nc + 1 + dc;
+            let nb = "─".repeat(nc);
+            let db = "─".repeat(dc);
+            let fb = "─".repeat(total);
+            let mut table = String::new();
+            table.push_str(&format!("╭{fb}╮\n"));
+            for (i, (label, rows)) in active_groups.iter().enumerate() {
+                if i > 0 {
+                    table.push_str(&format!("├{nb}┴{db}┤\n"));
+                }
+                table.push_str(&format!("│ {:<w$}│\n", label, w = total - 1));
+                table.push_str(&format!("├{nb}┬{db}┤\n"));
+                table.push_str(&format!(
+                    "│ {:<name_w$} │ {:<deps_w$} │\n",
+                    "Package", "Deps"
+                ));
+                table.push_str(&format!("├{nb}┼{db}┤\n"));
+                for m in rows {
+                    let dep_count = transitive_dep_counts.get(&m.package).copied().unwrap_or(0);
+                    table.push_str(&format!(
+                        "│ {:<name_w$} │ {:<deps_w$} │\n",
+                        m.package, dep_count,
+                    ));
+                }
+            }
+            table.push_str(&format!("╰{nb}┴{db}╯"));
+            tracing::info!("Test execution order:\n{table}");
+        }
+    }
+
+    for member in members {
         let common_opts = Arc::new(common_options.clone());
         let base_revspec = options
             .diff

src/crate_graph.rs

@@ -487,11 +487,11 @@ impl DependencyGraph {
                             deps.push(dep);
                             reverse_deps.push(node.id.clone());
                         } else if is_accepted_dep && !me.id_to_path.contains_key(dep_id) {
-                            tracing::warn!(
+                            tracing::trace!(
                                 source_id = %node.id,
                                 dep_id = %dep_id,
                                 dep_name = %node_dep.name,
-                                "dropping dependency edge: dep_id not found in registered workspace packages"
+                                "skipping external dependency edge"
                             );
                         }
                     }