dream_archivetool 1.1.0

Inspect, extract, create, and update Bethesda BSA and BA2 archives
Documentation
// SPDX-License-Identifier: MIT OR Apache-2.0

#![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}");
    }
}