cargo-rail: better 'init' testing; end to end testing; improved error messages. fixed 'audit/deny' in justfile

Author: loadingalias

justfile

@@ -9,9 +9,9 @@ check:
     cargo fmt --all
     cargo check --workspace --all-targets --all-features
     cargo clippy --workspace --all-targets --all-features --fix --allow-dirty -- -D warnings
-    # cargo deny check all
+    cargo deny check all
     RUSTDOCFLAGS="-D warnings" cargo doc --workspace --no-deps --all-features
-    # cargo audit
+    cargo audit
     @echo "✅ All checks passed!"
 
 ci-check:

src/commands/init.rs

@@ -616,6 +616,109 @@ fn write_config_file(config_path: &Path, content: &str) -> RailResult<()> {
   Ok(())
 }
 
+/// Standalone init that doesn't require WorkspaceContext
+///
+/// This is used when init is called on a directory that may not have
+/// a valid Cargo workspace yet (e.g., empty workspace or invalid state).
+pub fn run_init_standalone(
+  workspace_root: &Path,
+  output_path: &str,
+  force: bool,
+  _non_interactive: bool,
+  dry_run: bool,
+) -> RailResult<()> {
+  let config_path = workspace_root.join(output_path);
+
+  // 1. Check for existing config
+  if let Some(existing) = check_existing_config(workspace_root) {
+    if !force {
+      return Err(RailError::with_help(
+        format!(
+          "Configuration already exists at: {}\nUse --force to overwrite or --output to specify a different location",
+          existing.display()
+        ),
+        "Example: cargo rail init --force",
+      ));
+    }
+    if !dry_run {
+      println!("⚠️  Overwriting existing config at: {}", existing.display());
+    }
+  }
+
+  // 2. Detection phase
+  println!("🔍 Detecting workspace configuration...\n");
+
+  let toolchain_config = detect_toolchain_config(workspace_root)?;
+  let policy_config = detect_policy_config(workspace_root)?;
+
+  // Display detected settings
+  println!("  Toolchain: {} ({})", toolchain_config.channel, toolchain_config.profile);
+  if let Some(ref resolver) = policy_config.resolver {
+    println!("  Resolver: {}", resolver);
+  }
+  if let Some(ref edition) = policy_config.edition {
+    println!("  Edition: {}", edition);
+  }
+  if let Some(ref msrv) = policy_config.msrv {
+    println!("  MSRV: {}", msrv);
+  }
+  println!();
+
+  // 3. Build config
+  let config = RailConfig {
+    workspace: WorkspaceConfig {
+      root: PathBuf::from("."),
+    },
+    toolchain: toolchain_config,
+    policy: policy_config,
+    unify: UnifyConfig {
+      use_all_features: true,
+      sync_on_unify: true,
+      validate_targets: vec![],
+      max_parallel_jobs: 0,
+      pin_transitives: false,
+      pin_hosts: vec![],
+    },
+    security: SecurityConfig {
+      ssh_key_path: None,
+      signing_key_path: None,
+      require_signed_commits: false,
+      pr_branch_pattern: "rail/sync/{crate}/{timestamp}".to_string(),
+      protected_branches: vec!["main".to_string(), "master".to_string()],
+    },
+    splits: vec![],
+  };
+
+  // 4. Serialize with rich comments
+  let config_toml = serialize_config_with_comments(&config)?;
+
+  // 5. Output
+  if dry_run {
+    println!("--- {} ---", output_path);
+    println!("{}", config_toml);
+    println!("\n✅ Dry-run complete (no files written)");
+  } else {
+    // Create parent directory if needed
+    if let Some(parent) = config_path.parent() {
+      fs::create_dir_all(parent).map_err(|e| {
+        RailError::with_help(
+          format!("Failed to create directory {}: {}", parent.display(), e),
+          "Check file permissions",
+        )
+      })?;
+    }
+
+    write_config_file(&config_path, &config_toml)?;
+    println!("✅ Created {}", config_path.display());
+    println!("\nNext steps:");
+    println!("  1. Review and customize {}", output_path);
+    println!("  2. Run `cargo rail unify` to normalize dependencies");
+    println!("  3. Run `cargo rail test` for change-based testing");
+  }
+
+  Ok(())
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;

src/commands/mod.rs

@@ -32,7 +32,7 @@ pub mod watch;
 
 pub use affected::run_affected;
 pub use config_sync::run_config_sync;
-pub use init::run_init;
+pub use init::{run_init, run_init_standalone};
 pub use split::run_split;
 pub use status::run_status;
 pub use sync::run_sync;

src/commands/unify.rs

@@ -511,7 +511,7 @@ pub fn run_unify_check(
       cfg.toolchain.targets.clone()
     } else {
       println!("\n⚠️  --validate-targets flag set but no rail.toml found");
-      println!("Create .config/rail.toml with [toolchain.targets] to enable validation.");
+      println!("Run 'cargo rail init' to create a configuration file with [toolchain.targets].");
       return Ok(());
     };
 

src/error.rs

@@ -233,7 +233,7 @@ impl fmt::Display for ConfigError {
       ConfigError::NotFound { workspace_root } => {
         write!(
           f,
-          "No cargo-rail configuration found.\nExpected file: {}/.rail/config.toml",
+          "No cargo-rail configuration found in: {}\nSearched: rail.toml, .rail.toml, .cargo/rail.toml, .config/rail.toml\nRun 'cargo rail init' to create one.",
           workspace_root.display()
         )
       }

src/main.rs

@@ -231,7 +231,7 @@ fn get_styles() -> clap::builder::Styles {
 fn main() {
   let CargoCli::Rail(cli) = CargoCli::parse();
 
-  // Build workspace context once (single-load pattern)
+  // Get workspace root
   let workspace_root = match std::env::current_dir() {
     Ok(dir) => dir,
     Err(e) => {
@@ -240,6 +240,22 @@ fn main() {
     }
   };
 
+  // Handle init command specially - it doesn't require a valid workspace
+  if let Commands::Init {
+    output,
+    force,
+    non_interactive,
+    dry_run,
+  } = cli.command
+  {
+    let result = commands::run_init_standalone(&workspace_root, &output, force, non_interactive, dry_run);
+    if let Err(e) = result {
+      handle_error(e);
+    }
+    return;
+  }
+
+  // Build workspace context once (single-load pattern) for all other commands
   let ctx = match workspace::WorkspaceContext::build(&workspace_root) {
     Ok(ctx) => ctx,
     Err(e) => {
@@ -286,13 +302,8 @@ fn main() {
       }
     }
 
-    // Configuration Management
-    Commands::Init {
-      output,
-      force,
-      non_interactive,
-      dry_run,
-    } => commands::run_init(&ctx, &output, force, non_interactive, dry_run),
+    // Configuration Management (Init is handled above before building WorkspaceContext)
+    Commands::Init { .. } => unreachable!("Init command should be handled earlier"),
 
     // Dependency Unification
     Commands::Unify(unify_cmd) => match unify_cmd {

tests/integration/helpers.rs

@@ -14,7 +14,13 @@ pub struct TestWorkspace {
 impl TestWorkspace {
   /// Create a new test workspace with basic structure
   pub fn new() -> Result<Self> {
-    let root = TempDir::new()?;
+    Self::new_named("test-workspace")
+  }
+
+  /// Create a new test workspace with specific name
+  pub fn new_named(name: &str) -> Result<Self> {
+    let root = TempDir::new_in(std::env::temp_dir())
+      .with_context(|| format!("Failed to create temp dir for test workspace '{}'", name))?;
     let path = root.path().to_path_buf();
 
     // Initialize git repo with main as default branch
@@ -161,6 +167,15 @@ mod tests {{
   pub fn read_file(&self, path: &str) -> Result<String> {
     Ok(std::fs::read_to_string(self.path.join(path))?)
   }
+
+  /// Remove the rail.toml config file (useful for init tests)
+  pub fn remove_config(&self) -> Result<()> {
+    let config_path = self.path.join(".config/rail.toml");
+    if config_path.exists() {
+      std::fs::remove_file(config_path)?;
+    }
+    Ok(())
+  }
 }
 
 /// Run git command in a directory
@@ -189,16 +204,11 @@ pub fn run_cargo_rail(cwd: &Path, args: &[&str]) -> Result<Output> {
     .output()
     .context("Failed to run cargo-rail")?;
 
-  if !output.status.success() {
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    anyhow::bail!(
-      "cargo-rail command failed: cargo rail {}\nstdout: {}\nstderr: {}",
-      args.join(" "),
-      stdout,
-      stderr
-    );
-  }
-
   Ok(output)
 }
+
+/// Load RailConfig from a workspace
+pub fn load_rail_config(workspace_root: &Path) -> Result<cargo_rail::config::RailConfig> {
+  cargo_rail::config::RailConfig::load(workspace_root)
+    .context("Failed to load rail.toml configuration")
+}

tests/integration/mod.rs

@@ -2,6 +2,7 @@ mod helpers;
 mod test_affected;
 mod test_classification;
 mod test_git_notes;
+mod test_init;
 mod test_runner;
 mod test_split;
 mod test_sync;