rclean-cli 0.2.0

Find and safely clean rebuildable developer artifacts across local workspaces
use assert_cmd::Command;
use predicates::prelude::*;
#[cfg(target_os = "macos")]
use serde_json::Value;
#[cfg(target_os = "macos")]
use std::path::Path;
#[cfg(unix)]
use tempfile::TempDir;

#[cfg(target_os = "macos")]
fn make_non_empty_dir(path: &Path) -> Result<(), Box<dyn std::error::Error>> {
    std::fs::create_dir_all(path)?;
    std::fs::write(path.join("blob"), b"x")?;
    Ok(())
}

#[test]
fn system_flag_conflicts_with_positional_paths_home_and_tmp() {
    let mut with_path = Command::cargo_bin("rclean").unwrap();
    with_path
        .args(["scan", "--system", "/tmp/somepath"])
        .assert()
        .failure()
        .stderr(
            predicate::str::contains("cannot be used with")
                .or(predicate::str::contains("conflicts with")),
        );

    let mut with_home = Command::cargo_bin("rclean").unwrap();
    with_home
        .args(["scan", "--system", "--home"])
        .assert()
        .failure()
        .stderr(
            predicate::str::contains("cannot be used with")
                .or(predicate::str::contains("conflicts with")),
        );

    let mut with_tmp = Command::cargo_bin("rclean").unwrap();
    with_tmp
        .args(["scan", "--system", "--tmp"])
        .assert()
        .failure()
        .stderr(
            predicate::str::contains("cannot be used with")
                .or(predicate::str::contains("conflicts with")),
        );
}

#[cfg(target_os = "macos")]
#[test]
fn system_flag_reports_only_idleassetsd_anchor() -> Result<(), Box<dyn std::error::Error>> {
    let system = TempDir::new()?;
    let home = TempDir::new()?;
    let app_support = system.path().join("Library").join("Application Support");
    let idleassetsd = app_support.join("com.apple.idleassetsd");
    let sibling = app_support.join("node_modules");
    make_non_empty_dir(&idleassetsd)?;
    make_non_empty_dir(&sibling)?;

    let mut cmd = Command::cargo_bin("rclean")?;
    let output = cmd
        .env("HOME", home.path())
        .env("RCLEAN_TEST_SYSTEM_ROOTS", &idleassetsd)
        .args(["scan", "--system", "--json", "--min-size", "0"])
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let report: Value = serde_json::from_slice(&output)?;
    let canonical_idleassetsd = idleassetsd.canonicalize()?.display().to_string();
    let candidates: Vec<&Value> = report["projects"]
        .as_array()
        .into_iter()
        .flatten()
        .flat_map(|project| project["candidates"].as_array().into_iter().flatten())
        .collect();

    assert_eq!(
        report["roots"][0].as_str(),
        Some(canonical_idleassetsd.as_str())
    );
    assert_eq!(
        candidates.len(),
        1,
        "unexpected candidates: {candidates:#?}"
    );
    assert_eq!(
        candidates[0]["path"].as_str(),
        Some(canonical_idleassetsd.as_str())
    );
    assert_eq!(candidates[0]["ruleId"].as_str(), Some("apple.idleassetsd"));
    assert_eq!(candidates[0]["safety"].as_str(), Some("report-only"));
    assert_eq!(candidates[0]["requiresSudo"].as_bool(), Some(true));
    assert!(
        !serde_json::to_string(&report)?.contains(&sibling.display().to_string()),
        "system scan must not traverse sibling roots"
    );
    Ok(())
}

#[cfg(target_os = "macos")]
#[test]
fn system_flag_rejects_user_level_idleassetsd_anchor() -> Result<(), Box<dyn std::error::Error>> {
    let home = TempDir::new()?;
    let user_idleassetsd = home
        .path()
        .join("Library")
        .join("Application Support")
        .join("com.apple.idleassetsd");
    make_non_empty_dir(&user_idleassetsd)?;

    let mut cmd = Command::cargo_bin("rclean")?;
    cmd.env("HOME", home.path())
        .env("RCLEAN_TEST_SYSTEM_ROOTS", &user_idleassetsd)
        .args(["scan", "--system", "--json", "--min-size", "0"])
        .assert()
        .code(3)
        .stdout(predicate::str::contains("\"candidates\": 0"))
        .stdout(predicate::str::contains("apple.idleassetsd").not());
    Ok(())
}

#[cfg(target_os = "macos")]
#[test]
fn clean_system_all_reports_manual_sudo_reason_but_selects_none()
-> Result<(), Box<dyn std::error::Error>> {
    let system = TempDir::new()?;
    let home = TempDir::new()?;
    let idleassetsd = system
        .path()
        .join("Library")
        .join("Application Support")
        .join("com.apple.idleassetsd");
    make_non_empty_dir(&idleassetsd)?;

    let mut cmd = Command::cargo_bin("rclean")?;
    cmd.env("HOME", home.path())
        .env("RCLEAN_TEST_SYSTEM_ROOTS", &idleassetsd)
        .args(["clean", "--system", "--all", "--dry-run", "--min-size", "0"])
        .assert()
        .code(3)
        .stdout(predicate::str::contains("report-only"))
        .stdout(predicate::str::contains("will not run sudo"))
        .stdout(predicate::str::contains("Nothing selected."));

    assert!(idleassetsd.exists(), "report-only clean must not delete");
    Ok(())
}

#[cfg(target_os = "macos")]
#[test]
fn system_scan_plan_retains_requires_sudo_in_project_candidate()
-> Result<(), Box<dyn std::error::Error>> {
    let system = TempDir::new()?;
    let home = TempDir::new()?;
    let plan = system.path().join("plan.json");
    let idleassetsd = system
        .path()
        .join("Library")
        .join("Application Support")
        .join("com.apple.idleassetsd");
    make_non_empty_dir(&idleassetsd)?;

    let mut scan = Command::cargo_bin("rclean")?;
    scan.env("HOME", home.path())
        .env("RCLEAN_TEST_SYSTEM_ROOTS", &idleassetsd)
        .args([
            "scan",
            "--system",
            "--write-plan",
            plan.to_str().unwrap(),
            "--min-size",
            "0",
        ])
        .assert()
        .success();

    let plan_json: Value = serde_json::from_str(&std::fs::read_to_string(&plan)?)?;
    assert_eq!(plan_json["selected"].as_array().unwrap().len(), 0);
    let candidate = &plan_json["projects"][0]["candidates"][0];
    assert_eq!(candidate["ruleId"].as_str(), Some("apple.idleassetsd"));
    assert_eq!(candidate["requiresSudo"].as_bool(), Some(true));
    Ok(())
}

#[cfg(unix)]
#[test]
fn clean_plan_requires_sudo_refuses_without_invoking_sudo() -> Result<(), Box<dyn std::error::Error>>
{
    use std::os::unix::fs::PermissionsExt;

    let temp = TempDir::new()?;
    let bin = temp.path().join("bin");
    let fake_sudo = bin.join("sudo");
    let sudo_log = temp.path().join("sudo-called");
    std::fs::create_dir(&bin)?;
    std::fs::write(
        &fake_sudo,
        "#!/bin/sh\nprintf 'sudo called\\n' > \"$RCLEAN_FAKE_SUDO_LOG\"\nexit 0\n",
    )?;
    let mut permissions = std::fs::metadata(&fake_sudo)?.permissions();
    permissions.set_mode(0o755);
    std::fs::set_permissions(&fake_sudo, permissions)?;

    let plan = temp.path().join("plan.json");
    let candidate_path = temp
        .path()
        .join("Library")
        .join("Application Support")
        .join("com.apple.idleassetsd");
    let plan_json = serde_json::json!({
        "schemaVersion": 2,
        "toolVersion": "0.1.0",
        "generatedAt": "2026-05-06T00:00:00Z",
        "deleteMode": "trash",
        "roots": [temp.path().display().to_string()],
        "summary": {
            "projectsScanned": 1,
            "projectsWithCandidates": 1,
            "candidates": 1,
            "safeCandidates": 0,
            "cautionCandidates": 0,
            "blockedCandidates": 0,
            "reportOnlyCandidates": 1,
            "totalBytes": 0
        },
        "selected": [{
            "id": "01ARZ3NDEKTSV4RRFFQ69G5FAV",
            "path": candidate_path.display().to_string(),
            "ruleId": "apple.idleassetsd",
            "bytes": 0,
            "safety": "report-only",
            "requiresSudo": true,
            "category": "cache",
            "riskScore": 0.0
        }],
        "projects": []
    });
    std::fs::write(&plan, serde_json::to_string_pretty(&plan_json)?)?;

    let old_path = std::env::var_os("PATH").unwrap_or_default();
    let mut paths = vec![bin];
    paths.extend(std::env::split_paths(&old_path));
    let path = std::env::join_paths(paths)?;

    let mut clean = Command::cargo_bin("rclean")?;
    clean
        .env("PATH", path)
        .env("RCLEAN_FAKE_SUDO_LOG", &sudo_log)
        .args(["clean", "--plan", plan.to_str().unwrap(), "--yes"])
        .assert()
        .failure()
        .stderr(predicate::str::contains("will not run sudo"));

    assert!(!sudo_log.exists(), "rclean must not invoke sudo");
    Ok(())
}