use assert_cmd::Command;
use predicates::prelude::*;
use serde_json::Value;
use tempfile::TempDir;
#[test]
fn docker_report_missing_binary_is_explicit() -> Result<(), Box<dyn std::error::Error>> {
let temp = TempDir::new()?;
let missing = temp.path().join("missing-docker");
let output = Command::cargo_bin("rclean")?
.env("RCLEAN_DOCKER_BIN", &missing)
.args(["docker", "report", "--json"])
.assert()
.code(3)
.get_output()
.stdout
.clone();
let report: Value = serde_json::from_slice(&output)?;
assert_eq!(report["status"]["kind"].as_str(), Some("unavailable"));
assert!(
report["status"]["reason"]
.as_str()
.is_some_and(|reason| reason.contains("Docker CLI not found"))
);
assert_eq!(report["summary"]["resources"].as_u64(), Some(0));
Ok(())
}
#[cfg(unix)]
#[test]
fn docker_report_permission_denied_is_explicit() -> Result<(), Box<dyn std::error::Error>> {
let temp = TempDir::new()?;
let fake = write_fake_docker(
temp.path(),
r#"#!/bin/sh
printf '%s\n' "$*" >> "$RCLEAN_FAKE_DOCKER_LOG"
printf 'permission denied while trying to connect to the Docker daemon socket\n' >&2
exit 1
"#,
)?;
let output = Command::cargo_bin("rclean")?
.env("RCLEAN_DOCKER_BIN", &fake)
.env("RCLEAN_FAKE_DOCKER_LOG", temp.path().join("docker.log"))
.args(["docker", "report", "--json"])
.assert()
.code(3)
.get_output()
.stdout
.clone();
let report: Value = serde_json::from_slice(&output)?;
assert_eq!(report["status"]["kind"].as_str(), Some("permissionDenied"));
assert!(
report["status"]["reason"]
.as_str()
.is_some_and(|reason| reason.contains("permission denied"))
);
Ok(())
}
#[cfg(unix)]
#[test]
fn docker_report_timeout_is_explicit() -> Result<(), Box<dyn std::error::Error>> {
let temp = TempDir::new()?;
let fake = write_fake_docker(
temp.path(),
r#"#!/bin/sh
printf '%s\n' "$*" >> "$RCLEAN_FAKE_DOCKER_LOG"
sleep 5
"#,
)?;
let output = Command::cargo_bin("rclean")?
.env("RCLEAN_DOCKER_BIN", &fake)
.env("RCLEAN_FAKE_DOCKER_LOG", temp.path().join("docker.log"))
.args(["docker", "report", "--json", "--timeout", "1s"])
.assert()
.code(3)
.get_output()
.stdout
.clone();
let report: Value = serde_json::from_slice(&output)?;
assert_eq!(report["status"]["kind"].as_str(), Some("timedOut"));
assert_eq!(report["status"]["timeoutMs"].as_u64(), Some(1000));
Ok(())
}
#[cfg(unix)]
#[test]
fn docker_report_success_is_report_only_and_never_prunes() -> Result<(), Box<dyn std::error::Error>>
{
let temp = TempDir::new()?;
let log = temp.path().join("docker.log");
let fake = write_successful_fake_docker(temp.path())?;
let output = Command::cargo_bin("rclean")?
.env("RCLEAN_DOCKER_BIN", &fake)
.env("RCLEAN_FAKE_DOCKER_LOG", &log)
.args(["docker", "report", "--json"])
.assert()
.success()
.get_output()
.stdout
.clone();
let report: Value = serde_json::from_slice(&output)?;
let resources = report["resources"]
.as_array()
.expect("resources should be an array");
let ids: Vec<&str> = resources
.iter()
.filter_map(|resource| resource["resourceId"].as_str())
.collect();
assert_eq!(report["status"]["kind"].as_str(), Some("available"));
assert_eq!(report["summary"]["selectedResources"].as_u64(), Some(0));
assert!(ids.contains(&"docker.build_cache"));
assert!(ids.contains(&"docker.images"));
assert!(ids.contains(&"docker.local_volumes"));
assert!(ids.contains(&"docker.dangling_images"));
assert!(ids.contains(&"docker.stopped_containers"));
assert!(ids.contains(&"docker.networks"));
assert!(
resources
.iter()
.all(|resource| resource["selected"].as_bool() == Some(false))
);
let commands = std::fs::read_to_string(&log)?;
assert!(commands.contains("version --format {{json .Server}}"));
assert!(commands.contains("system df --format {{json .}}"));
assert!(!commands.contains("prune"));
assert!(!commands.contains(" rm"));
assert!(!commands.contains("delete"));
Ok(())
}
#[cfg(unix)]
#[test]
fn docker_report_large_output_is_explicit_error() -> Result<(), Box<dyn std::error::Error>> {
let temp = TempDir::new()?;
let fake = write_fake_docker(
temp.path(),
r#"#!/bin/sh
case "$*" in
'version --format {{json .Server}}')
printf '{"Version":"27.0.0"}\n'
;;
'system df --format {{json .}}')
i=0
while [ "$i" -lt 5000 ]; do
printf '{"Type":"Images","TotalCount":"2","Active":"1","Size":"1GB","Reclaimable":"500MB"}\n'
i=$((i + 1))
done
;;
*)
printf '{"ID":"ok"}\n'
;;
esac
"#,
)?;
let output = Command::cargo_bin("rclean")?
.env("RCLEAN_DOCKER_BIN", &fake)
.args(["docker", "report", "--json"])
.assert()
.code(3)
.get_output()
.stdout
.clone();
let report: Value = serde_json::from_slice(&output)?;
assert_eq!(report["status"]["kind"].as_str(), Some("error"));
assert!(
report["status"]["reason"]
.as_str()
.is_some_and(|reason| reason.contains("exceeded 65536 bytes")),
"unexpected report: {report:#?}"
);
Ok(())
}
#[cfg(unix)]
#[test]
fn doctor_default_does_not_probe_docker() -> Result<(), Box<dyn std::error::Error>> {
let temp = TempDir::new()?;
let log = temp.path().join("docker.log");
let fake = write_successful_fake_docker(temp.path())?;
Command::cargo_bin("rclean")?
.env("HOME", temp.path())
.env("RCLEAN_DOCKER_BIN", &fake)
.env("RCLEAN_FAKE_DOCKER_LOG", &log)
.arg("doctor")
.assert()
.code(3)
.stdout(predicate::str::contains("docker.daemon").not());
assert!(
!log.exists(),
"plain doctor must remain pure path checks and not invoke Docker"
);
Ok(())
}
#[test]
fn doctor_docker_probe_reports_missing_binary() -> Result<(), Box<dyn std::error::Error>> {
let temp = TempDir::new()?;
let missing = temp.path().join("missing-docker");
Command::cargo_bin("rclean")?
.env("HOME", temp.path())
.env("RCLEAN_DOCKER_BIN", &missing)
.args(["doctor", "--docker"])
.assert()
.code(3)
.stdout(predicate::str::contains("docker.daemon"))
.stdout(predicate::str::contains("Docker CLI not found"));
Ok(())
}
#[cfg(unix)]
fn write_successful_fake_docker(dir: &std::path::Path) -> std::io::Result<std::path::PathBuf> {
write_fake_docker(
dir,
r#"#!/bin/sh
printf '%s\n' "$*" >> "$RCLEAN_FAKE_DOCKER_LOG"
case "$*" in
'version --format {{json .Server}}')
printf '{"Version":"27.0.0"}\n'
;;
'system df --format {{json .}}')
printf '{"Type":"Images","TotalCount":"2","Active":"1","Size":"1GB","Reclaimable":"500MB (50%%)"}\n'
printf '{"Type":"Build Cache","TotalCount":"3","Active":"0","Size":"2GB","Reclaimable":"2GB"}\n'
printf '{"Type":"Local Volumes","TotalCount":"4","Active":"2","Size":"4GB","Reclaimable":"1GB (25%%)"}\n'
;;
'image ls --filter dangling=true --format {{json .}}')
printf '{"ID":"sha256:deadbeef"}\n'
;;
'container ls --all --filter status=exited --format {{json .}}')
printf '{"ID":"abc123","Names":"named-container"}\n'
;;
'network ls --format {{json .}}')
printf '{"ID":"net1","Name":"bridge"}\n'
;;
*)
printf 'unexpected docker command: %s\n' "$*" >&2
exit 40
;;
esac
"#,
)
}
#[cfg(unix)]
fn write_fake_docker(dir: &std::path::Path, script: &str) -> std::io::Result<std::path::PathBuf> {
use std::os::unix::fs::PermissionsExt;
let path = dir.join("docker");
std::fs::write(&path, script)?;
let mut permissions = std::fs::metadata(&path)?.permissions();
permissions.set_mode(0o755);
std::fs::set_permissions(&path, permissions)?;
Ok(path)
}