mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 05:14:24 +00:00
211 lines
10 KiB
Rust
211 lines
10 KiB
Rust
//! Each format's documents, built from scratch: what `sniff`, `info`, `renditions` and `outline`
|
|
//! return for them.
|
|
|
|
use super::common;
|
|
|
|
use common::*;
|
|
use craft_doc::{Error, Limits, RenditionKind, info, outline, rendition, renditions};
|
|
|
|
fn limits() -> Limits {
|
|
Limits::default()
|
|
}
|
|
|
|
/// A PDF-only importer need not decode a broken preview, for inline or blob payloads.
|
|
#[test]
|
|
fn selected_rendition_ignores_other_payloads() {
|
|
let inline = vectorcraft_json(
|
|
3,
|
|
&format!(r#""preview":{{"mime":"image/png","data":"!bad!"}}, "pdf":{{"mime":"application/pdf","data":"{}"}}"#, base64(PDF)),
|
|
);
|
|
let mut blob = vectorcraft_json(
|
|
4,
|
|
&format!(r#""preview":{{"mime":"image/png","blob":[{},100]}}, "pdf":{{"mime":"application/pdf","blob":[0,{}]}}"#, PDF.len() + 100, PDF.len()),
|
|
)
|
|
.into_bytes();
|
|
blob.extend(BLOB_MAGIC);
|
|
blob.extend(PDF);
|
|
for bytes in [inline.into_bytes(), blob] {
|
|
for bytes in [bytes.clone(), gzip(&bytes)] {
|
|
assert!(renditions(&bytes, &limits()).is_err());
|
|
let selected = rendition(&bytes, RenditionKind::Pdf, &limits()).unwrap().unwrap();
|
|
assert_eq!(selected.bytes, PDF);
|
|
assert!(rendition(&bytes, RenditionKind::Thumbnail, &limits()).is_err());
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Stored DEFLATE blocks contain the intact prefix; the next block has reserved BTYPE=3.
|
|
fn gzip_with_broken_tail(prefix: &[u8]) -> Vec<u8> {
|
|
let mut bytes = vec![0x1f, 0x8b, 8, 0, 0, 0, 0, 0, 0, 255];
|
|
for chunk in prefix.chunks(u16::MAX as usize) {
|
|
let length = chunk.len() as u16;
|
|
bytes.push(0); // Non-final stored block.
|
|
bytes.extend(length.to_le_bytes());
|
|
bytes.extend((!length).to_le_bytes());
|
|
bytes.extend(chunk);
|
|
}
|
|
bytes.push(7); // Final block with an invalid block type.
|
|
bytes.extend([0; 8]);
|
|
bytes
|
|
}
|
|
|
|
#[test]
|
|
fn selected_inline_pdf_ignores_gzip_damage_after_its_json_marker() {
|
|
for padding in [0, 128 * 1024] {
|
|
let json = vectorcraft_json(
|
|
4,
|
|
&format!(r#""padding":"{}","preview":{},"pdf":{}"#, "x".repeat(padding), blob("image/png", 0, 100), inline("application/pdf", PDF)),
|
|
);
|
|
let mut prefix = json.as_bytes().to_vec();
|
|
prefix.extend(BLOB_MAGIC);
|
|
let bytes = gzip_with_broken_tail(&prefix);
|
|
let mut exact = limits();
|
|
exact.max_json = json.len() as u64;
|
|
exact.max_total = (prefix.len() + PDF.len()) as u64;
|
|
exact.max_entry = PDF.len() as u64;
|
|
assert_eq!(rendition(&bytes, RenditionKind::Pdf, &exact).unwrap().unwrap().bytes, PDF);
|
|
assert!(matches!(rendition(&bytes, RenditionKind::Thumbnail, &limits()), Err(Error::Malformed(_))));
|
|
assert!(matches!(renditions(&bytes, &limits()), Err(Error::Malformed(_))));
|
|
exact.max_total -= 1;
|
|
assert!(matches!(rendition(&bytes, RenditionKind::Pdf, &exact), Err(Error::LimitExceeded(_))));
|
|
exact.max_total += 1;
|
|
exact.max_json -= 1;
|
|
assert!(matches!(rendition(&bytes, RenditionKind::Pdf, &exact), Err(Error::LimitExceeded(_))));
|
|
// A broken stream without a complete marker still fails, even after a complete JSON.
|
|
assert!(matches!(rendition(&gzip_with_broken_tail(json.as_bytes()), RenditionKind::Pdf, &limits()), Err(Error::Malformed(_))));
|
|
}
|
|
}
|
|
|
|
/// Ignored output is not charged, but gzip still has to traverse bytes before the PDF.
|
|
#[test]
|
|
fn selected_rendition_counts_its_payload_and_the_compressed_prefix() {
|
|
let preview = vec![0; 128 * 1024];
|
|
for before in [false, true] {
|
|
let (preview_at, pdf_at) = if before { (0, preview.len()) } else { (PDF.len(), 0) };
|
|
let json = vectorcraft_json(
|
|
4,
|
|
&format!(
|
|
r#""preview":{{"mime":"image/png","blob":[{preview_at},{}]}},"pdf":{{"mime":"application/pdf","blob":[{pdf_at},{}]}}"#,
|
|
preview.len(),
|
|
PDF.len()
|
|
),
|
|
);
|
|
let mut bytes = json.as_bytes().to_vec();
|
|
bytes.extend(BLOB_MAGIC);
|
|
if before {
|
|
bytes.extend(&preview);
|
|
bytes.extend(PDF);
|
|
} else {
|
|
bytes.extend(PDF);
|
|
bytes.extend(&preview);
|
|
}
|
|
let mut small = limits();
|
|
small.max_entry = PDF.len() as u64;
|
|
small.max_total = (json.len() + BLOB_MAGIC.len() + PDF.len()) as u64;
|
|
assert!(matches!(renditions(&bytes, &small), Err(Error::LimitExceeded(_))));
|
|
assert_eq!(rendition(&bytes, RenditionKind::Pdf, &small).unwrap().unwrap().bytes, PDF);
|
|
let compressed = rendition(&gzip(&bytes), RenditionKind::Pdf, &small);
|
|
if before {
|
|
assert!(matches!(compressed, Err(Error::LimitExceeded(_))));
|
|
} else {
|
|
assert_eq!(compressed.unwrap().unwrap().bytes, PDF);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn vectorcraft_members_after_the_json() {
|
|
// Version 4: the PDF after the marker, behind an image the document uses; the preview inline.
|
|
let image = vec![0xAB; 9000];
|
|
let preview = png(3, 3, 1);
|
|
let members = format!(r#""preview":{},"pdf":{}"#, inline("image/png", &preview), blob("application/pdf", image.len(), PDF.len()));
|
|
let mut file = vectorcraft_json(4, &members).into_bytes();
|
|
file.extend(BLOB_MAGIC);
|
|
file.extend(&image);
|
|
file.extend(PDF);
|
|
for bytes in [file.clone(), gzip(&file)] {
|
|
let r = renditions(&bytes, &limits()).unwrap();
|
|
assert_eq!(r.iter().map(|r| r.kind).collect::<Vec<_>>(), [RenditionKind::Thumbnail, RenditionKind::Pdf]);
|
|
assert_eq!(r[0].bytes, preview);
|
|
assert_eq!(r[1].bytes, PDF);
|
|
// The JSON alone answers info and outline.
|
|
assert_eq!(info(&bytes, &limits()).unwrap().version, 4);
|
|
assert_eq!(outline(&bytes, &limits()).unwrap().pages.len(), 2);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_compressed_marker_across_the_reader_s_64_kib_chunks() {
|
|
// The marker starts at every offset around the first 64 KiB boundary of the unpacked stream.
|
|
let base = vectorcraft_json(4, &format!(r#""pdf":{},"pad":"""#, blob("application/pdf", 0, PDF.len())));
|
|
for json_len in (64 << 10) - 12..(64 << 10) + 2 {
|
|
let json = base.replacen(r#""pad":"""#, &format!(r#""pad":"{}""#, "x".repeat(json_len - base.len())), 1);
|
|
assert_eq!(json.len(), json_len);
|
|
let mut file = json.into_bytes();
|
|
file.extend(BLOB_MAGIC);
|
|
file.extend(PDF);
|
|
let gz = gzip(&file);
|
|
assert_eq!(info(&gz, &limits()).unwrap().version, 4, "{json_len}");
|
|
assert_eq!(outline(&gz, &limits()).unwrap().pages.len(), 2, "{json_len}");
|
|
assert_eq!(renditions(&gz, &limits()).unwrap()[0].bytes, PDF, "{json_len}");
|
|
}
|
|
}
|
|
|
|
/// Full-member identity is retained even when its dimensions differ from the document canvas.
|
|
#[test]
|
|
fn pcraft_prefers_the_full_size_composite_without_reading_the_preview() {
|
|
let full = png(80, 60, 30);
|
|
let small_preview = png(4, 3, 20);
|
|
for preview in [false, true] {
|
|
let manifest = pcraft_manifest(1, "[]", r#", "full_composite":"composite/full.png", "composite":"composite/preview.png""#);
|
|
let mut entries = vec![store("manifest.json", manifest.as_bytes()), deflated("composite/full.png", &full)];
|
|
if preview {
|
|
entries.push(store("composite/preview.png", &small_preview));
|
|
}
|
|
let r = renditions(&zip(&entries), &limits()).unwrap();
|
|
assert_eq!(r.len(), 1);
|
|
assert_eq!((r[0].kind, r[0].mime.as_str(), &r[0].bytes), (RenditionKind::Composite, "image/png", &full));
|
|
assert!(r[0].is_full_composite);
|
|
let canvas = outline(&zip(&entries), &limits()).unwrap().canvas.unwrap();
|
|
assert_eq!((canvas.width, canvas.height), (640, 480), "the flag does not validate the 80 by 60 PNG against this canvas");
|
|
}
|
|
let manifest = pcraft_manifest(1, "[]", r#", "full_composite":"composite/full.png", "composite":"composite/preview.png""#);
|
|
let mut tight = limits();
|
|
tight.max_entry = manifest.len().max(full.len()) as u64;
|
|
let oversized = vec![0; tight.max_entry as usize + 1];
|
|
for preview in [store("composite/preview.png", &oversized), deflated("composite/preview.png", &oversized)] {
|
|
let pc = zip(&[store("manifest.json", manifest.as_bytes()), deflated("composite/full.png", &full), preview]);
|
|
assert_eq!(renditions(&pc, &tight).unwrap()[0].bytes, full);
|
|
}
|
|
let manifest = pcraft_manifest(1, "[]", r#", "full_composite":"composite/full.png""#);
|
|
let pc = zip(&[store("manifest.json", manifest.as_bytes()), store("composite/full.png", &full)]);
|
|
let selected = renditions(&pc, &limits()).unwrap().pop().unwrap();
|
|
assert_eq!(selected.bytes, full);
|
|
assert!(selected.is_full_composite);
|
|
let mut small = limits();
|
|
small.max_entry = manifest.len() as u64;
|
|
// Keep the manifest under the limit while bounding the image independently.
|
|
let large = vec![0; manifest.len() + full.len()];
|
|
let pc = zip(&[store("manifest.json", manifest.as_bytes()), store("composite/full.png", &large)]);
|
|
assert!(matches!(renditions(&pc, &small), Err(Error::LimitExceeded(_))));
|
|
}
|
|
|
|
/// Invalid declarations and missing full entries never silently fall back to the preview.
|
|
#[test]
|
|
fn pcraft_refuses_invalid_or_missing_full_size_composites() {
|
|
for field in [r#""../full.png""#, r#""composite/preview.png""#, "12", r#""composite/full.png", "full_composite":null"#] {
|
|
let manifest = pcraft_manifest(1, "[]", &format!(r#", "full_composite":{field}"#));
|
|
let pc = zip(&[store("manifest.json", manifest.as_bytes()), store("composite/preview.png", &png(4, 3, 20))]);
|
|
assert!(matches!(renditions(&pc, &limits()), Err(Error::Malformed(_))), "{field}");
|
|
}
|
|
let manifest = pcraft_manifest(1, "[]", r#", "full_composite":"composite/full.png", "composite":"composite/preview.png""#);
|
|
let pc = zip(&[store("manifest.json", manifest.as_bytes()), store("composite/preview.png", &png(4, 3, 20))]);
|
|
assert!(matches!(renditions(&pc, &limits()), Err(Error::Malformed(_))));
|
|
let manifest = pcraft_manifest(1, "[]", r#", "full_composite":null, "composite":"composite/preview.png""#);
|
|
let preview = png(4, 3, 20);
|
|
let pc = zip(&[store("manifest.json", manifest.as_bytes()), store("composite/preview.png", &preview)]);
|
|
let selected = renditions(&pc, &limits()).unwrap().pop().unwrap();
|
|
assert_eq!(selected.bytes, preview);
|
|
assert!(!selected.is_full_composite);
|
|
}
|