socket-patch-core 3.3.0

//! Integration coverage for `socket_patch_core::patch::diff::apply_diff`.
//!
//! Mirrors the lib-level unit tests but lives in `tests/` so it
//! appears as integration coverage (counted by `cargo llvm-cov`
//! against the e2e bar) rather than lib coverage.

use qbsdiff::Bsdiff;
use socket_patch_core::patch::diff::apply_diff;
use std::io::Cursor;

/// Local helper: produce a bsdiff 4 delta from `before` → `after`.
fn make_delta(before: &[u8], after: &[u8]) -> Vec<u8> {
    let mut delta = Vec::new();
    Bsdiff::new(before, after)
        .compare(Cursor::new(&mut delta))
        .expect("bsdiff compare");
    delta
}

/// Happy path: round-trip a small text mutation through bsdiff +
/// apply_diff.
#[test]
fn text_delta_round_trip() {
    let before = b"the quick brown fox jumps over the lazy dog";
    let after = b"the quick brown cat jumps over the lazy dog";
    let delta = make_delta(before, after);
    let result = apply_diff(before, &delta).unwrap();
    assert_eq!(result, after);
}

/// Binary buffer with scattered mutations — exercises the
/// non-textual code path of qbsdiff.
#[test]
fn binary_delta_round_trip() {
    let before: Vec<u8> = (0..1024u32).map(|i| (i % 251) as u8).collect();
    let mut after = before.clone();
    for i in [10usize, 200, 500, 900] {
        after[i] = after[i].wrapping_add(7);
    }
    let delta = make_delta(&before, &after);
    let result = apply_diff(&before, &delta).unwrap();
    assert_eq!(result, after);
}

/// Edge case: empty `before` → non-empty `after`. Some bsdiff
/// implementations special-case the no-source branch; verify
/// ours doesn't.
#[test]
fn empty_to_nonempty() {
    let before: &[u8] = b"";
    let after = b"hello";
    let delta = make_delta(before, after);
    let result = apply_diff(before, &delta).unwrap();
    assert_eq!(result, after);
}

/// Malformed delta header must surface as an Io error, not a
/// panic.
#[test]
fn malformed_delta_errors() {
    let bogus = b"not a real bsdiff delta header";
    let result = apply_diff(b"anything", bogus);
    assert!(result.is_err(), "expected Err on malformed delta");
}

/// Applying a delta to the *wrong* source must not panic — the
/// caller is expected to verify the resulting `after_hash`
/// against the manifest, but the library itself never traps.
#[test]
fn wrong_source_does_not_panic() {
    let src_a = b"AAAAAAAAAAAAAAAAAAAA";
    let src_b = b"BBBBBBBBBBBBBBBBBBBB";
    let target = b"CCCCCCCCCCCCCCCCCCCC";
    let delta = make_delta(src_a, target);
    // Result content is unspecified; never-panic is the contract.
    let _ = apply_diff(src_b, &delta);
}