Files
craft-libs/crates/deckcraft-format/src/tests.rs
T
FredApps 254e9a409b Add craft-deckcraft-format: the .deckcraft package layer from DeckCraft (#1748)
The package layer of DeckCraft's native format, moved from storytold/deckcraft
crates/format at 0d5c0b85 (lib.rs, finite.rs): the mimetype and legacy
SlideCraft type, sniffing, the presentation.json envelope (generic over the
app's presentation), the NaN-safe JSON writer (Finite), the reader that patches
null numbers in older files, member names and compression choice, and the
bounded, budget-charged member reads with the format's limits.

The presentation model, repair, media and chart-part mapping, and outline/RTF
stay in DeckCraft. Writes go through craft-zip's deterministic writer; the
consumer's golden test shows the package bytes are unchanged.

Part of #778.
2026-11-15 23:44:31 +01:00

236 lines
10 KiB
Rust

#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use serde::{Deserialize, Serialize};
use super::*;
/// A stand-in for an app's presentation: plain numbers, an optional number and a tagged enum
/// (whose `null`s serde reports only at the end of the enclosing object).
#[derive(Debug, Default, PartialEq, Serialize, Deserialize)]
struct Deck {
#[serde(default)]
width: f64,
#[serde(default)]
zoom: Option<f64>,
#[serde(default)]
shapes: Vec<Shape>,
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind")]
enum Shape {
Box { x: f64, y: f64 },
Line { len: f64 },
}
fn package(members: &[Member<'_>]) -> Vec<u8> {
write(&Deck { width: 960.0, ..Default::default() }, "Test 1", members).unwrap()
}
#[test]
fn a_package_holds_mimetype_then_manifest_then_members_in_order() {
let png = [0x89, b'P', b'N', b'G'];
let svg = b"<svg/>".repeat(20);
let bytes = package(&[
Member { name: &media_entry(7), content_type: "image/png", bytes: &png },
Member { name: &media_entry(8), content_type: "image/svg+xml", bytes: &svg },
Member { name: &chart_part_entry(0), content_type: "application/zip", bytes: b"PK" },
]);
assert!(sniff(&bytes));
let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes.as_slice())).unwrap();
assert_eq!(z.len(), 5);
let methods: Vec<_> = (0..z.len())
.map(|i| {
let f = z.by_index(i).unwrap();
(f.name().unwrap().into_owned(), f.compression())
})
.collect();
use zip::CompressionMethod::{Deflated, Stored};
assert_eq!(
methods,
[("mimetype", Stored), ("presentation.json", Deflated), ("media/7", Stored), ("media/8", Deflated), ("chart-parts/0", Stored)]
.map(|(n, m)| (n.to_string(), m))
);
// The mimetype is the first, stored member, readable in place.
assert_eq!(craft_zip::stored_mimetype(&bytes), Some(MIMETYPE.as_bytes()));
let (m, mut p) = Package::open_manifest::<Deck>(&bytes, MAX_MANIFEST).unwrap();
assert_eq!((m.format.as_str(), m.version, m.generator.as_str(), m.presentation.width), (FORMAT, VERSION, "Test 1", 960.0));
assert_eq!(p.read(&media_entry(8)).unwrap(), svg);
assert_eq!(p.declared_size(&media_entry(7)), Some(4));
assert_eq!(p.declared_size("media/99"), None);
}
#[test]
fn the_manifest_is_compact_json_with_its_fields_in_order() {
let bytes = package(&[]);
let mut p = Package::open(&bytes).unwrap();
let json = String::from_utf8(p.read(MANIFEST_ENTRY).unwrap()).unwrap();
assert_eq!(json, r#"{"format":"deckcraft","version":1,"generator":"Test 1","presentation":{"width":960.0,"zoom":null,"shapes":[]}}"#);
}
#[test]
fn non_finite_numbers_are_written_as_zero_and_read_back() {
let deck = Deck { width: f64::NAN, zoom: Some(f64::INFINITY), shapes: vec![Shape::Box { x: f64::NEG_INFINITY, y: 2.0 }] };
let bytes = write(&deck, "t", &[]).unwrap();
let (m, _) = Package::open_manifest::<Deck>(&bytes, MAX_MANIFEST).unwrap();
assert_eq!(m.presentation, Deck { width: 0.0, zoom: Some(0.0), shapes: vec![Shape::Box { x: 0.0, y: 2.0 }] });
}
/// Files written before [`Finite`] (plain serde_json: NaN as `null`) open too, including a
/// `null` inside a tagged enum, where serde reports only the enclosing object.
#[test]
fn older_manifests_with_null_numbers_parse() {
let cases: [(&str, Deck); 3] = [
(r#"{"format":"deckcraft","version":1,"generator":"old","presentation":{"width":null}}"#, Deck::default()),
(
r#"{"format":"deckcraft","version":1,"generator":"old","presentation":{"width":3,"shapes":[{"kind":"Box","x":null,"y":4}]}}"#,
Deck { width: 3.0, shapes: vec![Shape::Box { x: 0.0, y: 4.0 }], ..Default::default() },
),
(
"{\n \"format\": \"deckcraft\",\n \"version\": 1,\n \"generator\": \"t\",\n \"presentation\": {\"shapes\": [{\"kind\": \"Line\", \"len\": null}]}\n}",
Deck { shapes: vec![Shape::Line { len: 0.0 }], ..Default::default() },
),
];
for (json, want) in cases {
let m = parse_manifest::<Deck>(json.as_bytes()).unwrap_or_else(|e| panic!("{json}: {e}"));
assert_eq!(m.presentation, want, "{json}");
}
}
/// Only `null`s where numbers belong are patched: other damage still fails.
#[test]
fn other_manifest_damage_is_still_reported() {
let ok = br#"{"format": "deckcraft", "version": 1, "generator": "t", "presentation": {}}"#;
assert!(parse_manifest::<Deck>(ok).is_ok());
let bad = br#"{"format": null, "version": 1, "generator": "t", "presentation": {}}"#;
assert!(matches!(parse_manifest::<Deck>(bad), Err(FormatError::Damaged(_))));
assert!(parse_manifest::<Deck>(&ok[..ok.len() - 3]).is_err());
}
#[test]
fn a_manifest_full_of_nulls_is_refused_within_bounds() {
let shapes = (0..2000).map(|_| r#"{"kind":"Box","x":1,"y":"not a number"}"#).collect::<Vec<_>>().join(",");
let json = format!(r#"{{"format":"deckcraft","version":1,"generator":"t","presentation":{{"width":null,"shapes":[{shapes}]}}}}"#);
assert!(matches!(parse_manifest::<Deck>(json.as_bytes()), Err(FormatError::Damaged(_))));
}
#[test]
fn what_is_not_a_package_is_not_ours() {
for bytes in [&b""[..], b"PK\x03\x04garbage", &[0u8; 1000]] {
assert!(matches!(Package::open_manifest::<Deck>(bytes, MAX_MANIFEST), Err(FormatError::NotOurs(_))));
}
// A ZIP without the manifest, and one from another app.
let mut z = craft_zip::Writer::new();
z.add("mimetype", b"application/zip", craft_zip::Compression::Stored).unwrap();
let no_manifest = z.finish().unwrap();
let err = Package::open_manifest::<Deck>(&no_manifest, MAX_MANIFEST).err().unwrap();
assert_eq!(err.to_string(), "not a DeckCraft file: no presentation.json");
let mut z = craft_zip::Writer::new();
z.add(MANIFEST_ENTRY, br#"{"format":"other","version":1,"generator":"x","presentation":{}}"#, craft_zip::Compression::Deflated).unwrap();
let other = z.finish().unwrap();
let err = Package::open_manifest::<Deck>(&other, MAX_MANIFEST).err().unwrap();
assert_eq!(err.to_string(), "not a DeckCraft file: other");
// A truncated package is an error, not a panic.
let mut b = package(&[]);
b.truncate(b.len() / 2);
assert!(Package::open_manifest::<Deck>(&b, MAX_MANIFEST).is_err());
}
#[test]
fn legacy_slidecraft_packages_are_recognised() {
let mut z = craft_zip::Writer::new();
z.add(MIMETYPE_ENTRY, LEGACY_MIMETYPE.as_bytes(), craft_zip::Compression::Stored).unwrap();
assert!(sniff(&z.finish().unwrap()));
assert!(!sniff(b"PK\x03\x04 application/zip"));
assert!(!sniff(MIMETYPE.as_bytes()));
}
#[test]
fn an_oversized_manifest_is_refused_before_inflating() {
let bytes = package(&[]);
let size = Package::open(&bytes).unwrap().declared_size(MANIFEST_ENTRY).unwrap();
assert!(Package::open_manifest::<Deck>(&bytes, size).is_ok());
let err = Package::open_manifest::<Deck>(&bytes, size - 1).err().unwrap();
assert_eq!(err.to_string(), "damaged file: presentation.json is too large");
}
#[test]
fn a_member_that_inflates_past_its_declared_size_stops_at_the_limit() {
// Declared sizes are the file's word: a stored member whose header lies is still capped.
let data = vec![7u8; 100];
let bytes = package(&[Member { name: &media_entry(1), content_type: "image/png", bytes: &data }]);
let mut p = Package::open(&bytes).unwrap();
assert_eq!(p.read_max(&media_entry(1), 100).unwrap().len(), 100);
assert!(p.read_max(&media_entry(1), 99).is_err());
let err = p.read("media/2").unwrap_err();
assert!(matches!(err, FormatError::Damaged(ref m) if m.starts_with("media/2: ")), "{err}");
}
#[test]
fn corrupt_members_are_charged_for_what_they_inflated() {
let a = b"PICTURE-AAAAAAAAAAAA";
let b = b"PICTURE-BBBBBBBBBBBB";
let mut bytes = package(&[
Member { name: &media_entry(1), content_type: "image/png", bytes: a },
Member { name: &media_entry(2), content_type: "image/png", bytes: b },
]);
// Corrupt both stored members, so each fails its CRC only after inflating all its bytes.
for tag in [b"PICTURE-AAAA", b"PICTURE-BBBB"] {
let at = bytes.windows(tag.len()).position(|w| w == tag).unwrap();
bytes[at] ^= 0xff;
}
let mut p = Package::open(&bytes).unwrap();
let mut left = 30;
assert!(p.read_charged(&media_entry(1), &mut left).is_err());
assert_eq!(left, 10, "a failed read still spends what it inflated");
// The second fits a fresh budget on its own, but not what is left: refused before inflating.
let err = p.read_charged(&media_entry(2), &mut left).unwrap_err();
assert_eq!(err.to_string(), "damaged file: media/2 is too large");
assert_eq!(left, 10);
}
#[test]
fn chart_part_names_are_exact() {
assert_eq!(chart_part_entry(3), "chart-parts/3");
assert!(is_chart_part_entry("chart-parts/0"));
assert!(is_chart_part_entry("chart-parts/12"));
for not in ["media/1", "chart-parts/../0", "chart-parts/00", "chart-parts/-1", "chart-parts/", "chart-parts/+1", "chart-parts/1 "] {
assert!(!is_chart_part_entry(not), "{not}");
}
}
#[test]
fn compressed_content_types_are_stored() {
for stored in [
"image/jpeg",
"image/png",
"video/mp4",
"audio/mpeg",
"audio/mp4",
"application/zip",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet+zip",
] {
assert!(is_compressed(stored), "{stored}");
}
for deflated in ["image/svg+xml", "image/gif", "audio/wav", "application/octet-stream", "text/plain"] {
assert!(!is_compressed(deflated), "{deflated}");
}
}
#[test]
fn duplicate_members_are_a_write_error() {
let err = write(
&Deck::default(),
"t",
&[Member { name: "media/1", content_type: "x", bytes: b"a" }, Member { name: "media/1", content_type: "x", bytes: b"b" }],
)
.unwrap_err();
assert!(matches!(err, FormatError::Write(_)), "{err}");
}
#[test]
fn the_default_budget_is_the_formats_limits() {
assert_eq!(Budget::default(), Budget { total: 4 << 30, items: 100_000, manifest: 256 << 20 });
assert_eq!(Budget::media(10, 2), Budget { total: 10, items: 2, manifest: MAX_MANIFEST });
}