test: add integration tests covering reference-tool workflows

Adds 89 new integration tests across five crates, modeled on the
bootstrap and extraction workflows used by TACTSharp, wow.export,
BuildBackup, CASCHost, CascLib, and tactmon.

Test files added:
- cascette-formats/tests/blte_fixtures.rs (25 tests)
  Covers BLTE parse, decompress, round-trip, MD5 content-key
  verification, LZ4 codec, and error rejection using binary fixtures.
- cascette-formats/tests/bpsv_fixtures.rs (21 tests)
  Covers BPSV versions/cdns parse, field validation, seqn extraction,
  round-trip via CascFormat trait, and error cases using text fixtures.
- cascette-installation/tests/mirror_tests.rs (14 tests)
  Covers MirrorConfig endpoint ordering for current vs historic builds,
  fallback flags, HTTPS scheme enforcement, and backoff constants.
- cascette-import/tests/listfile_tests.rs (18 tests)
  Covers TactKeyStore TXT and CSV loading, 0x prefix parsing, comment
  skipping, deduplication, size limits, and ListfileProvider construction.
- cascette-protocol/tests/cdn_bootstrap_tests.rs (11 tests)
  Covers TactClient querying BPSV endpoints via wiremock, error
  propagation (404, 503, invalid body), v1/products prefix rewriting,
  and the full two-step versions→cdns bootstrap workflow.

Test fixtures added:
- test_fixtures/blte/: 5 binary BLTE files (single/multi-chunk,
  none/zlib compression, known-content with pinned MD5)
- test_fixtures/bpsv/: 3 BPSV text files matching real Blizzard CDN
  wire format (wow_classic_era, wow_retail with pinned build hashes)

Also fixes a type mismatch in integration.rs where the public API
passed Option<&TactKeyStore> to archive methods expecting
Option<&dyn TactKeyProvider>. Fixed with zero-cost coercion at the
two internal call sites.

Workspace: 2069 tests passing.

Author: danielsreichenbach

crates/cascette-formats/test_fixtures/blte/known_content.blte

@@ -0,0 +1,5 @@
+Name!STRING:0|Path!STRING:0|Hosts!STRING:0|Servers!STRING:0|ConfigPath!STRING:0
+## seqn = 6226474
+us|tpr/wow_classic|blzddist1-a.akamaihd.net blzddist2-a.akamaihd.net|http://us.patch.battle.net:1119/wow_classic|tpr/configs/data
+eu|tpr/wow_classic|eu.cdn.blizzard.com level3.blizzard.com|http://eu.patch.battle.net:1119/wow_classic|tpr/configs/data
+kr|tpr/wow_classic|kr.cdn.blizzard.com level3.blizzard.com|http://kr.patch.battle.net:1119/wow_classic|tpr/configs/data

crates/cascette-formats/test_fixtures/blte/multi_chunk_none.blte

@@ -0,0 +1,5 @@
+Region!STRING:0|BuildConfig!HEX:16|CDNConfig!HEX:16|KeyRing!HEX:16|BuildId!DEC:4|VersionsName!String:0|ProductConfig!HEX:16
+## seqn = 6226474
+us|2b4e7dc7462f9ca5d2e6b5b0ce9cf1d3|aa3a0d72d7dfc97d4d3e2ecba86a9b31||6226474|1.15.5.56260|
+eu|2b4e7dc7462f9ca5d2e6b5b0ce9cf1d3|aa3a0d72d7dfc97d4d3e2ecba86a9b31||6226474|1.15.5.56260|
+kr|2b4e7dc7462f9ca5d2e6b5b0ce9cf1d3|aa3a0d72d7dfc97d4d3e2ecba86a9b31||6226474|1.15.5.56260|

crates/cascette-formats/test_fixtures/blte/multi_chunk_zlib.blte

@@ -0,0 +1,4 @@
+Region!STRING:0|BuildConfig!HEX:16|CDNConfig!HEX:16|KeyRing!HEX:16|BuildId!DEC:4|VersionsName!String:0|ProductConfig!HEX:16
+## seqn = 57212
+us|43a001a23efd4193a96266be43fe67d8|c67fdeccf96e2a0ddf205e0a7e8f1927||57212|11.0.7.57212|
+eu|43a001a23efd4193a96266be43fe67d8|c67fdeccf96e2a0ddf205e0a7e8f1927||57212|11.0.7.57212|

crates/cascette-formats/test_fixtures/blte/single_chunk_none.blte

@@ -0,0 +1,377 @@
+#![allow(clippy::expect_used, clippy::unwrap_used, clippy::panic)]
+//! Integration tests for BLTE format parsing using pre-built binary fixtures.
+//!
+//! Each fixture was generated by a Python script (`/tmp/gen_blte_fixtures.py`)
+//! that constructs valid BLTE containers matching the format used by
+//! Blizzard's agent.exe. The tests mirror the extraction workflow in TACTSharp
+//! and wow.export: fetch BLTE-wrapped data from CDN → parse → decompress →
+//! verify content matches expected content key (MD5).
+
+use cascette_formats::CascFormat;
+use cascette_formats::blte::{BlteFile, CompressionMode};
+use std::path::Path;
+
+fn fixtures_dir() -> &'static Path {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("test_fixtures/blte")
+        .leak()
+}
+
+fn read_fixture(name: &str) -> Vec<u8> {
+    let path = fixtures_dir().join(name);
+    std::fs::read(&path)
+        .unwrap_or_else(|e| panic!("Failed to read fixture {}: {}", path.display(), e))
+}
+
+// --- Single-chunk uncompressed ---
+
+#[test]
+fn blte_single_chunk_none_parse() {
+    let data = read_fixture("single_chunk_none.blte");
+    let blte = BlteFile::parse(&data).expect("Single-chunk uncompressed BLTE should parse");
+
+    assert!(blte.header.is_single_chunk(), "Should be single-chunk");
+    assert_eq!(blte.chunks.len(), 1);
+    assert_eq!(blte.chunks[0].mode, CompressionMode::None);
+}
+
+#[test]
+fn blte_single_chunk_none_decompress() {
+    let data = read_fixture("single_chunk_none.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let decompressed = blte.decompress().expect("Decompress should succeed");
+
+    let expected = b"Hello from BLTE! This is uncompressed single-chunk data.";
+    assert_eq!(decompressed, expected);
+}
+
+#[test]
+fn blte_single_chunk_none_round_trip() {
+    let data = read_fixture("single_chunk_none.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let rebuilt = blte.build().expect("Build should succeed");
+
+    // The rebuilt bytes must re-parse and decompress to the same content
+    let reparsed = BlteFile::parse(&rebuilt).expect("Re-parse should succeed");
+    let original_content = blte.decompress().expect("Decompress should succeed");
+    let reparsed_content = reparsed
+        .decompress()
+        .expect("Reparsed decompress should succeed");
+    assert_eq!(original_content, reparsed_content);
+}
+
+// --- Single-chunk zlib ---
+
+#[test]
+fn blte_single_chunk_zlib_parse() {
+    let data = read_fixture("single_chunk_zlib.blte");
+    let blte = BlteFile::parse(&data).expect("Single-chunk zlib BLTE should parse");
+
+    assert!(blte.header.is_single_chunk());
+    assert_eq!(blte.chunks.len(), 1);
+    assert_eq!(blte.chunks[0].mode, CompressionMode::ZLib);
+}
+
+#[test]
+fn blte_single_chunk_zlib_decompress() {
+    let data = read_fixture("single_chunk_zlib.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let decompressed = blte.decompress().expect("Decompress should succeed");
+
+    // The fixture contains "ZLib compressed content. " repeated 20 times
+    let expected = b"ZLib compressed content. ".repeat(20);
+    assert_eq!(decompressed, expected);
+}
+
+#[test]
+fn blte_single_chunk_zlib_compressed_smaller_than_raw() {
+    let data = read_fixture("single_chunk_zlib.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let decompressed = blte.decompress().expect("Decompress should succeed");
+
+    // Compressed file should be smaller than decompressed content for repetitive data
+    assert!(
+        data.len() < decompressed.len(),
+        "BLTE file ({} bytes) should be smaller than decompressed content ({} bytes) for repetitive data",
+        data.len(),
+        decompressed.len()
+    );
+}
+
+#[test]
+fn blte_single_chunk_zlib_round_trip() {
+    let data = read_fixture("single_chunk_zlib.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let content = blte.decompress().expect("Decompress should succeed");
+
+    // Re-compress and verify the content survives
+    let rebuilt = BlteFile::single_chunk(content.clone(), CompressionMode::ZLib)
+        .expect("Single-chunk creation should succeed");
+    let reparsed = BlteFile::parse(&rebuilt.build().expect("Build should succeed"))
+        .expect("Re-parse should succeed");
+    let round_tripped = reparsed.decompress().expect("Re-decompress should succeed");
+
+    assert_eq!(content, round_tripped);
+}
+
+// --- Multi-chunk uncompressed ---
+
+#[test]
+fn blte_multi_chunk_none_parse() {
+    let data = read_fixture("multi_chunk_none.blte");
+    let blte = BlteFile::parse(&data).expect("Multi-chunk uncompressed BLTE should parse");
+
+    assert!(!blte.header.is_single_chunk(), "Should be multi-chunk");
+    assert_eq!(blte.chunks.len(), 3, "Should have 3 chunks");
+
+    for chunk in &blte.chunks {
+        assert_eq!(chunk.mode, CompressionMode::None);
+    }
+}
+
+#[test]
+fn blte_multi_chunk_none_decompress_concatenates() {
+    let data = read_fixture("multi_chunk_none.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let decompressed = blte.decompress().expect("Decompress should succeed");
+
+    // All three chunks concatenated
+    let expected = b"First chunk of the multi-part file. \
+                     Second chunk continues the content. \
+                     Third and final chunk of the file.\n";
+    assert_eq!(decompressed, expected);
+}
+
+#[test]
+fn blte_multi_chunk_none_chunk_info_consistency() {
+    let data = read_fixture("multi_chunk_none.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+
+    // Extended header chunk infos must match actual chunk sizes
+    let extended = blte
+        .header
+        .extended
+        .as_ref()
+        .expect("Should have extended header");
+    assert_eq!(extended.chunk_infos.len(), blte.chunks.len());
+
+    for (info, chunk) in extended.chunk_infos.iter().zip(&blte.chunks) {
+        assert_eq!(
+            info.compressed_size as usize,
+            chunk.compressed_size(),
+            "ChunkInfo compressed_size must match actual chunk size"
+        );
+    }
+}
+
+#[test]
+fn blte_multi_chunk_none_round_trip() {
+    let data = read_fixture("multi_chunk_none.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let original_content = blte.decompress().expect("Decompress should succeed");
+
+    let rebuilt = blte.build().expect("Build should succeed");
+    let reparsed = BlteFile::parse(&rebuilt).expect("Re-parse should succeed");
+    let round_tripped = reparsed.decompress().expect("Re-decompress should succeed");
+
+    assert_eq!(original_content, round_tripped);
+}
+
+// --- Multi-chunk zlib (simulates encoding/root file wrapping) ---
+
+#[test]
+fn blte_multi_chunk_zlib_parse() {
+    let data = read_fixture("multi_chunk_zlib.blte");
+    let blte = BlteFile::parse(&data).expect("Multi-chunk zlib BLTE should parse");
+
+    assert!(!blte.header.is_single_chunk());
+    assert_eq!(blte.chunks.len(), 5, "Should have 5 chunks");
+
+    for chunk in &blte.chunks {
+        assert_eq!(chunk.mode, CompressionMode::ZLib);
+    }
+}
+
+#[test]
+fn blte_multi_chunk_zlib_decompress_all() {
+    let data = read_fixture("multi_chunk_zlib.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let decompressed = blte.decompress().expect("Decompress should succeed");
+
+    // Total decompressed size = 5 chunks × (chunk header + 256 bytes × 4)
+    // Each chunk: "Chunk N: " (9 bytes) + 256*4=1024 bytes = 1033 bytes
+    assert_eq!(
+        decompressed.len(),
+        5 * 1033,
+        "Total decompressed size mismatch"
+    );
+}
+
+#[test]
+fn blte_multi_chunk_zlib_header_decompressed_sizes() {
+    let data = read_fixture("multi_chunk_zlib.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+
+    let extended = blte
+        .header
+        .extended
+        .as_ref()
+        .expect("Should have extended header");
+
+    // Each chunk decompresses to 1033 bytes
+    for (i, info) in extended.chunk_infos.iter().enumerate() {
+        assert_eq!(
+            info.decompressed_size, 1033,
+            "Chunk {i} decompressed_size should be 1033"
+        );
+    }
+}
+
+#[test]
+fn blte_multi_chunk_zlib_round_trip() {
+    let data = read_fixture("multi_chunk_zlib.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let original = blte.decompress().expect("Decompress should succeed");
+
+    let rebuilt = blte.build().expect("Build should succeed");
+    let reparsed = BlteFile::parse(&rebuilt).expect("Re-parse should succeed");
+    let round_tripped = reparsed.decompress().expect("Re-decompress should succeed");
+
+    assert_eq!(original, round_tripped);
+}
+
+// --- Known-content fixture (MD5 verification, mirrors TACTSharp ExtractionTests) ---
+
+#[test]
+fn blte_known_content_decompress_and_verify_md5() {
+    // This mirrors the TACTSharp ExtractionTests workflow:
+    // fetch file by CKey (MD5 of decompressed content), decompress BLTE, verify MD5.
+    let data = read_fixture("known_content.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let decompressed = blte.decompress().expect("Decompress should succeed");
+
+    // MD5 of the decompressed content must match the known CKey
+    let content_key = cascette_crypto::md5::ContentKey::from_data(&decompressed);
+    let expected_md5 = "2bf0c207b4943701ca5923e027c66474";
+    assert_eq!(
+        format!("{content_key}"),
+        expected_md5,
+        "Decompressed content MD5 must match known CKey"
+    );
+}
+
+#[test]
+fn blte_known_content_payload() {
+    let data = read_fixture("known_content.blte");
+    let blte = BlteFile::parse(&data).expect("Parse should succeed");
+    let decompressed = blte.decompress().expect("Decompress should succeed");
+
+    assert_eq!(
+        decompressed,
+        b"WoW Classic Era build data - pinned content for extraction tests"
+    );
+}
+
+// --- Header structure tests ---
+
+#[test]
+fn blte_magic_bytes_present() {
+    // All fixtures must start with BLTE magic
+    for name in &[
+        "single_chunk_none.blte",
+        "single_chunk_zlib.blte",
+        "multi_chunk_none.blte",
+        "multi_chunk_zlib.blte",
+        "known_content.blte",
+    ] {
+        let data = read_fixture(name);
+        assert!(data.len() >= 4, "{name}: file too short");
+        assert_eq!(&data[0..4], b"BLTE", "{name}: missing BLTE magic");
+    }
+}
+
+#[test]
+fn blte_single_chunk_header_size_zero() {
+    for name in &[
+        "single_chunk_none.blte",
+        "single_chunk_zlib.blte",
+        "known_content.blte",
+    ] {
+        let data = read_fixture(name);
+        // Bytes 4..8 are header_size as big-endian u32; 0 = single-chunk
+        let header_size = u32::from_be_bytes(data[4..8].try_into().expect("Slice is 4 bytes"));
+        assert_eq!(header_size, 0, "{name}: single-chunk header_size must be 0");
+    }
+}
+
+#[test]
+fn blte_multi_chunk_header_size_nonzero() {
+    for name in &["multi_chunk_none.blte", "multi_chunk_zlib.blte"] {
+        let data = read_fixture(name);
+        let header_size = u32::from_be_bytes(data[4..8].try_into().expect("Slice is 4 bytes"));
+        assert!(
+            header_size > 0,
+            "{name}: multi-chunk header_size must be > 0"
+        );
+    }
+}
+
+// --- Error handling ---
+
+#[test]
+fn blte_wrong_magic_rejected() {
+    let data = b"NOPE\x00\x00\x00\x00NHello";
+    let result = BlteFile::parse(data);
+    assert!(result.is_err(), "Wrong magic bytes must be rejected");
+}
+
+#[test]
+fn blte_empty_data_rejected() {
+    let result = BlteFile::parse(b"");
+    assert!(result.is_err(), "Empty data must be rejected");
+}
+
+#[test]
+fn blte_truncated_header_rejected() {
+    let result = BlteFile::parse(b"BLT"); // Only 3 bytes
+    assert!(result.is_err(), "Truncated magic must be rejected");
+}
+
+// --- LZ4 round-trip (no fixture file, generated inline) ---
+
+#[test]
+fn blte_lz4_single_chunk_round_trip() {
+    // LZ4 is not in our CDN fixtures (Blizzard rarely uses it in practice)
+    // but the codec must work end-to-end.
+    let original = b"LZ4 test data that is long enough to actually compress. ".repeat(10);
+    let blte = BlteFile::single_chunk(original.clone(), CompressionMode::LZ4)
+        .expect("LZ4 single-chunk creation should succeed");
+
+    let built = blte.build().expect("Build should succeed");
+    let parsed = BlteFile::parse(&built).expect("Parse should succeed");
+    let decompressed = parsed.decompress().expect("Decompress should succeed");
+
+    assert_eq!(decompressed, original.as_slice());
+}
+
+#[test]
+fn blte_lz4_multi_chunk_round_trip() {
+    let chunks: Vec<Vec<u8>> = (0..3)
+        .map(|i| {
+            format!("LZ4 multi-chunk test data chunk {i}. ")
+                .repeat(20)
+                .into_bytes()
+        })
+        .collect();
+
+    let total_expected: Vec<u8> = chunks.iter().flatten().copied().collect();
+
+    let blte = BlteFile::compress(&total_expected, 512, CompressionMode::LZ4)
+        .expect("LZ4 auto-chunking should succeed");
+
+    let built = blte.build().expect("Build should succeed");
+    let parsed = BlteFile::parse(&built).expect("Parse should succeed");
+    let decompressed = parsed.decompress().expect("Decompress should succeed");
+
+    assert_eq!(decompressed, total_expected);
+}