mktool 1.5.9

/*
 * Copyright (c) 2024 Jonathan Perkin <jonathan@perkin.org.uk>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

use std::env;
use std::fs;
use std::io::Write;
use std::path::PathBuf;
use std::process::{Command, Stdio};

const MKTOOL: &str = env!("CARGO_BIN_EXE_mktool");

type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;

/*
 * Invalid arguments.
 *
 * XXX: This is not fully compatible, checksum.awk exits 3, we exit 2, but
 * unfortunatly this is hardcoded in clap.
 */
#[test]
fn test_checksum_invalid_args() -> Result<()> {
    let cmd = Command::new(MKTOOL).arg("checksum").output()?;
    assert_eq!(cmd.status.code(), Some(2));
    Ok(())
}

/*
 * Test running with no input files.
 */
#[test]
fn test_checksum_no_input() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let cmd = Command::new(MKTOOL).arg("checksum").arg(distinfo).output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());
    Ok(())
}

/*
 * Pass a nonexistent distinfo file.  The error message should include both
 * the filename and the reason for the failure.
 */
#[test]
fn test_checksum_bad_distinfo() -> Result<()> {
    let distinfo = PathBuf::from("/nonexistent");
    let cmd = Command::new(MKTOOL).arg("checksum").arg(&distinfo).output()?;
    let stderr = String::from_utf8_lossy(&cmd.stderr);
    assert_eq!(cmd.status.code(), Some(3));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert!(
        stderr.contains("/nonexistent"),
        "expected filename in error: {stderr}"
    );
    assert!(
        stderr.contains("No such file") || stderr.contains("not found"),
        "expected error reason: {stderr}"
    );
    Ok(())
}

/*
 * Passing a file that doesn't exist in distinfo should print a message
 * to stderr and exit 2.
 */
#[test]
fn test_checksum_bad_distfile() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg(&distinfo)
        .arg("foo")
        .output()?;
    assert_eq!(cmd.status.code(), Some(2));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(
        cmd.stderr,
        "checksum: No checksum recorded for foo\n".as_bytes()
    );
    Ok(())
}

/*
 * Tests against a valid full distfile test.
 */
#[test]
fn test_checksum_valid_distfile() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let output = format!(
        "{}\n{}\n",
        "=> Checksum BLAKE2s OK for digest1.txt",
        "=> Checksum SHA512 OK for digest1.txt"
    );
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg(&distinfo)
        .arg("digest1.txt")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());

    /*
     * Identical to previous except the path to the distfile is
     * different (but still valid).
     */
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg(&distinfo)
        .arg("../data/digest1.txt")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());
    /*
     * Valid, but we only request a single algorithm each time.
     */
    let output = "=> Checksum BLAKE2s OK for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("BLAKE2s")
        .arg(&distinfo)
        .arg("digest1.txt")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());

    let output = "=> Checksum SHA512 OK for digest2.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA512")
        .arg(&distinfo)
        .arg("digest2.txt")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());

    /*
     * Output should be in distinfo order, with errors last, regardless of
     * order of command line arguments.
     */
    let output = format!(
        "{}\n{}\n{}\n{}\n",
        "=> Checksum BLAKE2s OK for digest1.txt",
        "=> Checksum SHA512 OK for digest1.txt",
        "=> Checksum BLAKE2s OK for digest2.txt",
        "=> Checksum SHA512 OK for digest2.txt"
    );
    let outerr = "checksum: No checksum recorded for digest11.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg(&distinfo)
        .arg("digest2.txt")
        .arg("digest11.txt")
        .arg("digest1.txt")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(2));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, outerr.as_bytes());
    Ok(())
}

/*
 * Test input from file / stdin.
 */
#[test]
fn test_checksum_input_file() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let tmpdir = PathBuf::from(env!("CARGO_TARGET_TMPDIR"));
    let tmpfile = tmpdir.join("test_checksum_input_file.txt");
    fs::write(&tmpfile, "digest2.txt\n")?;
    let output = format!(
        "{}\n{}\n{}\n{}\n",
        "=> Checksum BLAKE2s OK for digest1.txt",
        "=> Checksum SHA512 OK for digest1.txt",
        "=> Checksum BLAKE2s OK for digest2.txt",
        "=> Checksum SHA512 OK for digest2.txt"
    );
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg(&distinfo)
        .arg("-I")
        .arg(&tmpfile)
        .arg("digest1.txt")
        .current_dir("tests/data")
        .output()?;
    fs::remove_file(&tmpfile)?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());
    Ok(())
}

#[test]
fn test_checksum_input_stdin() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let output = format!(
        "{}\n{}\n{}\n{}\n",
        "=> Checksum BLAKE2s OK for digest1.txt",
        "=> Checksum SHA512 OK for digest1.txt",
        "=> Checksum BLAKE2s OK for digest2.txt",
        "=> Checksum SHA512 OK for digest2.txt"
    );
    let mut cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg(&distinfo)
        .arg("-I")
        .arg("-")
        .arg("digest2.txt")
        .current_dir("tests/data")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .spawn()?;
    let mut stdin = cmd.stdin.take().ok_or("failed to open stdin")?;
    std::thread::spawn(move || {
        let _ = stdin.write_all("digest1.txt".as_bytes());
    });
    let out = cmd.wait_with_output()?;
    assert_eq!(out.status.code(), Some(0));
    assert_eq!(out.stdout, output.as_bytes());
    assert_eq!(out.stderr, "".as_bytes());
    Ok(())
}

/*
 * Test strip suffix mode.  Use filename digest1.txt.suffix but validate
 * against the digest1.txt distinfo entry.
 */
#[test]
fn test_checksum_strip_mode() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");

    let output = "=> Checksum SHA512 OK for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA512")
        .arg("-s")
        .arg(".suffix")
        .arg(&distinfo)
        .arg("digest1.txt.suffix")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());

    /* Invalid suffix strip.  */
    let output = "checksum: No checksum recorded for digest1.txt.suffix\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-s")
        .arg(".badsuffix")
        .arg(&distinfo)
        .arg("digest1.txt.suffix")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(2));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(cmd.stderr, output.as_bytes());
    Ok(())
}

/*
 * Verify that with -s, the file actually opened for hashing is the
 * original (suffix-included) path, not the suffix-stripped lookup name.
 * The setup writes the suffix-included file into a directory that does
 * NOT contain the suffix-stripped filename, so opening by the stripped
 * name would fail with ENOENT.  Also verify that MissingChecksum reports
 * the stripped name (matching checksum.awk), not the supplied path.
 */
#[test]
fn test_checksum_strip_opens_original() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let mut src = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    src.push("tests/data/digest1.txt");
    let tmpdir = PathBuf::from(env!("CARGO_TARGET_TMPDIR"))
        .join("test_checksum_strip_opens_original");
    fs::create_dir_all(&tmpdir)?;
    let tmpfile = tmpdir.join("digest1.txt.fetchtmp");
    fs::copy(&src, &tmpfile)?;
    assert!(!tmpdir.join("digest1.txt").exists());

    let output = "=> Checksum SHA512 OK for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA512")
        .arg("-s")
        .arg(".fetchtmp")
        .arg(&distinfo)
        .arg("digest1.txt.fetchtmp")
        .current_dir(&tmpdir)
        .output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());

    let output = "checksum: No SHA1 checksum recorded for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA1")
        .arg("-s")
        .arg(".fetchtmp")
        .arg(&distinfo)
        .arg("digest1.txt.fetchtmp")
        .current_dir(&tmpdir)
        .output()?;
    fs::remove_dir_all(&tmpdir)?;
    assert_eq!(cmd.status.code(), Some(2));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(cmd.stderr, output.as_bytes());
    Ok(())
}

/*
 * Test strip suffix mode via -I input file.
 */
#[test]
fn test_checksum_strip_input() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let tmpdir = PathBuf::from(env!("CARGO_TARGET_TMPDIR"));
    let tmpfile = tmpdir.join("test_checksum_strip_input.txt");
    fs::write(&tmpfile, "digest1.txt.suffix\n")?;
    let output = "=> Checksum SHA512 OK for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA512")
        .arg("-s")
        .arg(".suffix")
        .arg("-I")
        .arg(&tmpfile)
        .arg(&distinfo)
        .current_dir("tests/data")
        .output()?;
    fs::remove_file(&tmpfile)?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());

    /*
     * Input file with suffix that doesn't match should use the original
     * filename for the distinfo lookup.
     */
    let tmpfile = tmpdir.join("test_checksum_strip_input_nomatch.txt");
    fs::write(&tmpfile, "digest1.txt\n")?;
    let output = "=> Checksum SHA512 OK for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA512")
        .arg("-s")
        .arg(".badsuffix")
        .arg("-I")
        .arg(&tmpfile)
        .arg(&distinfo)
        .current_dir("tests/data")
        .output()?;
    fs::remove_file(&tmpfile)?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());
    Ok(())
}

/*
 * Passing a nonexistent file to -I should print an error and exit 1.
 */
#[test]
fn test_checksum_bad_input_file() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-I")
        .arg("/nonexistent/inputfile")
        .arg(&distinfo)
        .output()?;
    let stderr = String::from_utf8_lossy(&cmd.stderr);
    assert_eq!(cmd.status.code(), Some(1));
    assert!(
        stderr.contains("/nonexistent/inputfile"),
        "expected filename in error: {stderr}"
    );
    assert!(
        stderr.contains("No such file") || stderr.contains("not found"),
        "expected error reason: {stderr}"
    );
    Ok(())
}

/*
 * Missing distfile with a specific algorithm requested should include the
 * algorithm name in the error message.
 */
#[test]
fn test_checksum_bad_distfile_algorithm() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA512")
        .arg(&distinfo)
        .arg("foo")
        .output()?;
    assert_eq!(cmd.status.code(), Some(2));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(
        cmd.stderr,
        "checksum: No SHA512 checksum recorded for foo\n".as_bytes()
    );
    Ok(())
}

/*
 * Invalid algorithm name.
 */
#[test]
fn test_checksum_bad_algorithm() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("BOGUS")
        .arg(&distinfo)
        .arg("digest1.txt")
        .current_dir("tests/data")
        .output()?;
    let stderr = String::from_utf8_lossy(&cmd.stderr);
    assert_ne!(cmd.status.code(), Some(0));
    assert!(
        stderr.contains("BOGUS"),
        "expected algorithm name in error: {stderr}"
    );
    Ok(())
}

/*
 * Verify -j flag is accepted.
 */
#[test]
fn test_checksum_jobs_flag() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let output = "=> Checksum SHA512 OK for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA512")
        .arg("-j")
        .arg("1")
        .arg(&distinfo)
        .arg("digest1.txt")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());
    Ok(())
}

/*
 * Verify MKTOOL_JOBS environment variable is accepted.
 */
#[test]
fn test_checksum_jobs_env() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let output = "=> Checksum SHA512 OK for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA512")
        .arg(&distinfo)
        .arg("digest1.txt")
        .env("MKTOOL_JOBS", "1")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());
    Ok(())
}

/*
 * No checksum type recorded.
 */
#[test]
fn test_checksum_no_checksum() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let output = format!(
        "{}\n{}\n",
        "checksum: No SHA1 checksum recorded for digest1.txt",
        "checksum: No SHA1 checksum recorded for nonexistent.txt",
    );
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA1")
        .arg(&distinfo)
        .arg("digest1.txt")
        .arg("nonexistent.txt")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(2));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(cmd.stderr, output.as_bytes());
    Ok(())
}

/*
 * Patch mode.
 */
#[test]
fn test_checksum_patch() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let output = "=> Checksum SHA1 OK for patch-Makefile\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-p")
        .arg(&distinfo)
        .arg("patch-Makefile")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());
    Ok(())
}

/*
 * Patch mode where the path doesn't exactly match the distinfo entry,
 * ensuring that find_entry() functionality is tested.
 */
#[test]
fn test_checksum_patch_path() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo");
    let output = "=> Checksum SHA1 OK for patch-Makefile\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-p")
        .arg(&distinfo)
        .arg("../data/patch-Makefile")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(0));
    assert_eq!(cmd.stdout, output.as_bytes());
    assert_eq!(cmd.stderr, "".as_bytes());
    Ok(())
}

/*
 * Now run some of the same tests but with a modified distinfo file containing
 * invalid checksums.
 */
#[test]
fn test_checksum_mismatch() -> Result<()> {
    let mut distinfo = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    distinfo.push("tests/data/distinfo.bad");

    // Only the first checksum mismatch is printed on failure.
    let output = "checksum: Checksum BLAKE2s mismatch for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg(&distinfo)
        .arg("digest1.txt")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(1));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(cmd.stderr, output.as_bytes());

    let output = "checksum: Checksum SHA512 mismatch for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-a")
        .arg("SHA512")
        .arg(&distinfo)
        .arg("digest1.txt")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(1));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(cmd.stderr, output.as_bytes());

    let output = "checksum: Checksum SHA1 mismatch for patch-Makefile\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-p")
        .arg(&distinfo)
        .arg("patch-Makefile")
        .current_dir("tests/data")
        .output()?;
    assert_eq!(cmd.status.code(), Some(1));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(cmd.stderr, output.as_bytes());

    /*
     * Repeat the above with paths that contain a directory component, so
     * the input path differs from the bare filename recorded in distinfo.
     */
    let output = "checksum: Checksum BLAKE2s mismatch for digest1.txt\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg(&distinfo)
        .arg("data/digest1.txt")
        .current_dir("tests")
        .output()?;
    assert_eq!(cmd.status.code(), Some(1));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(cmd.stderr, output.as_bytes());

    let output = "checksum: Checksum SHA1 mismatch for patch-Makefile\n";
    let cmd = Command::new(MKTOOL)
        .arg("checksum")
        .arg("-p")
        .arg(&distinfo)
        .arg("data/patch-Makefile")
        .current_dir("tests")
        .output()?;
    assert_eq!(cmd.status.code(), Some(1));
    assert_eq!(cmd.stdout, "".as_bytes());
    assert_eq!(cmd.stderr, output.as_bytes());
    Ok(())
}