#![cfg(feature = "cli")]
use std::process::{Command, Output, Stdio};
use tempfile::TempDir;
fn bin() -> &'static str {
env!("CARGO_BIN_EXE_dream_archivetool")
}
fn run(args: &[&str]) -> Output {
Command::new(bin()).args(args).output().unwrap()
}
fn write_test_archive(dir: &TempDir) -> std::path::PathBuf {
let archive = dir.path().join("test.bsa");
let mut builder = dream_archive::Tes3BsaBuilder::new();
builder
.add_bytes("textures/example.dds", b"payload")
.unwrap();
builder.write_path(&archive).unwrap();
archive
}
fn write_input_file(dir: &TempDir, name: &str) -> std::path::PathBuf {
let input = dir.path().join(name);
std::fs::write(&input, b"payload").unwrap();
input
}
#[test]
fn no_subcommand_prints_help_to_stdout_successfully() {
let output = run(&[]);
assert!(output.status.success());
assert!(String::from_utf8_lossy(&output.stdout).contains("Usage:"));
assert!(output.stderr.is_empty());
}
#[test]
fn clap_misuse_exits_nonzero_and_reports_to_stderr() {
let output = run(&["extract"]);
assert_eq!(output.status.code(), Some(2));
assert!(output.stdout.is_empty());
assert!(String::from_utf8_lossy(&output.stderr).contains("error:"));
}
#[test]
fn runtime_error_reports_to_stderr_and_exits_one() {
let output = run(&["info", "missing.bsa"]);
assert_eq!(output.status.code(), Some(1));
assert!(output.stdout.is_empty());
assert!(String::from_utf8_lossy(&output.stderr).starts_with("ERROR:"));
}
#[test]
fn extract_stdout_writes_exact_payload_bytes() {
let dir = TempDir::new().unwrap();
let archive = write_test_archive(&dir);
let archive = archive.to_str().unwrap();
let output = run(&["extract", archive, "textures/example.dds", "--stdout"]);
assert!(output.status.success());
assert_eq!(output.stdout, b"payload");
assert!(output.stderr.is_empty());
}
#[test]
fn dry_run_without_json_prints_json_plan() {
let dir = TempDir::new().unwrap();
let archive = write_test_archive(&dir);
let archive = archive.to_str().unwrap();
let output = run(&["extract-all", archive, "--dry-run"]);
assert!(output.status.success());
assert!(output.stderr.is_empty());
let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
assert_eq!(json["operation"], "extract-all");
assert!(json["entries"].as_array().is_some());
}
#[test]
fn create_dry_run_without_json_prints_json_plan() {
let dir = TempDir::new().unwrap();
let input = write_input_file(&dir, "input.txt");
let output_archive = dir.path().join("created.bsa");
let output = run(&[
"create",
output_archive.to_str().unwrap(),
input.to_str().unwrap(),
"--format",
"tes3",
"--dry-run",
]);
assert!(output.status.success());
assert!(output.stderr.is_empty());
let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
assert_eq!(json["operation"], "create");
assert!(json["entries"].as_array().is_some());
}
#[test]
fn add_dry_run_without_json_prints_json_plan() {
let dir = TempDir::new().unwrap();
let archive = write_test_archive(&dir);
let input = write_input_file(&dir, "new_file.txt");
let output = run(&[
"add",
archive.to_str().unwrap(),
input.to_str().unwrap(),
"--dry-run",
]);
assert!(output.status.success());
assert!(output.stderr.is_empty());
let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
assert_eq!(json["operation"], "add");
assert!(json["entries"].as_array().is_some());
}
#[test]
fn extract_all_dry_run_reports_existing_target_as_conflict() {
let dir = TempDir::new().unwrap();
let archive = write_test_archive(&dir);
let archive = archive.to_str().unwrap();
let out = dir.path().join("out");
std::fs::create_dir_all(out.join("textures")).unwrap();
std::fs::write(out.join("textures/example.dds"), b"existing").unwrap();
let out = out.to_str().unwrap();
let output = run(&["extract-all", archive, "--output", out, "--dry-run"]);
assert!(output.status.success());
let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
assert_eq!(json["entries"][0]["action"], "conflict");
let output = run(&["extract-all", archive, "--output", out]);
assert_eq!(output.status.code(), Some(1));
assert!(String::from_utf8_lossy(&output.stderr).contains("target already exists"));
}
#[test]
fn bare_archive_names_resolve_in_the_working_directory() {
let dir = TempDir::new().unwrap();
write_input_file(&dir, "input.txt");
write_input_file(&dir, "extra.txt");
let run_here = |args: &[&str]| {
let output = Command::new(bin())
.args(args)
.current_dir(dir.path())
.output()
.unwrap();
assert!(
output.status.success(),
"{args:?}: {}",
String::from_utf8_lossy(&output.stderr)
);
output
};
run_here(&[
"create",
"MyMod.bsa",
"input.txt",
"--format",
"tes3",
"--fsync",
]);
let plan = run_here(&[
"add",
"MyMod.bsa",
"extra.txt",
"--output",
"MyMod-2.bsa",
"--dry-run",
]);
let plan: serde_json::Value = serde_json::from_slice(&plan.stdout).unwrap();
assert_eq!(plan["output"], "MyMod-2.bsa");
run_here(&[
"add",
"MyMod.bsa",
"extra.txt",
"--output",
"MyMod-2.bsa",
"--fsync",
]);
run_here(&["add", "MyMod.bsa", "extra.txt", "--fsync"]);
assert!(dir.path().join("MyMod-2.bsa").is_file());
let listed = run_here(&["list", "MyMod.bsa"]);
assert_eq!(listed.stdout, b"extra.txt\ninput.txt\n");
}
#[test]
fn a_closed_stdout_ends_the_program_quietly() {
let dir = TempDir::new().unwrap();
let archive = dir.path().join("big.bsa");
let mut builder = dream_archive::Tes3BsaBuilder::new();
for index in 0..4000 {
builder
.add_bytes(format!("textures/a/long/folder/name/{index:05}.dds"), b"x")
.unwrap();
}
builder.add_bytes("big.bin", vec![b'x'; 1 << 20]).unwrap();
builder.write_path(&archive).unwrap();
let archive = archive.to_str().unwrap();
for args in [
&["list", archive][..],
&["list", "--json", archive],
&["extract", archive, "big.bin", "--stdout"],
&["--generate-completion", "bash"],
] {
let mut child = Command::new(bin())
.args(args)
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.unwrap();
drop(child.stdout.take());
let output = child.wait_with_output().unwrap();
assert!(
output.status.success() && output.stderr.is_empty(),
"{args:?}: {:?}, {}",
output.status,
String::from_utf8_lossy(&output.stderr)
);
}
}
#[test]
fn errors_name_the_command_line_options() {
let dir = TempDir::new().unwrap();
let input = dir.path().join("input");
std::fs::create_dir_all(&input).unwrap();
std::fs::write(input.join("readme.txt"), b"payload").unwrap();
let archive = dir.path().join("out.bsa");
let (archive, input_path) = (archive.to_str().unwrap(), input.to_str().unwrap());
let output = run(&[
"create",
archive,
input_path,
"--format",
"tes3",
"--compress",
]);
assert_eq!(output.status.code(), Some(1));
assert_eq!(
String::from_utf8_lossy(&output.stderr),
"ERROR: archive error: --compress is not valid with --format tes3\n"
);
#[cfg(unix)]
{
std::os::unix::fs::symlink(input.join("readme.txt"), input.join("link.txt")).unwrap();
let output = run(&["create", archive, input_path, "--format", "tes3"]);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(output.status.code(), Some(1));
assert!(
stderr.contains("refusing to follow symlink input path"),
"{stderr}"
);
assert!(
stderr.contains("pass --follow-symlinks to opt in"),
"{stderr}"
);
assert!(!stderr.contains("follow_symlinks"), "{stderr}");
}
}