beffroi-tools/tests/reporter.rs

456 lines
16 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

use pptx_reporter::{archive, engine, model::*, playback, reports};
use std::{fs, fs::File, io::Write, path::Path, sync::atomic::AtomicBool};
use zip::write::SimpleFileOptions;
fn picture(id: &str, trim: &str) -> String {
format!(
r#"<p:pic><p:nvPicPr><p:cNvPr id="{id}"/><p:nvPr><a:videoFile r:link="legacy"/><p14:media r:embed="media">{trim}</p14:media></p:nvPr></p:nvPicPr></p:pic>"#
)
}
fn timing(id: &str, attrs: &str) -> String {
format!(
r#"<p:video><p:cMediaNode><p:cTn id="{id}" {attrs}/><p:tgtEl><p:spTgt spid="{id}"/></p:tgtEl></p:cMediaNode></p:video>"#
)
}
fn slide(shapes: &str, animation: &str) -> String {
format!(
r#"<p:sld xmlns:p="{}" xmlns:r="{}" xmlns:p14="{}" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><p:cSld><p:spTree>{shapes}</p:spTree></p:cSld><p:timing>{animation}</p:timing></p:sld>"#,
archive::P,
archive::R,
archive::P14
)
}
fn deck(path: &Path, slides: &[(String, String)], media: bool) {
let mut zip = zip::ZipWriter::new(File::create(path).unwrap());
let mut write = |name: &str, bytes: &[u8]| {
zip.start_file(name, SimpleFileOptions::default()).unwrap();
zip.write_all(bytes).unwrap();
};
if media {
write("ppt/media/shared.mp4", b"video");
}
for (i, (shapes, animation)) in slides.iter().enumerate() {
write(
&format!("ppt/slides/slide{}.xml", i + 1),
slide(shapes, animation).as_bytes(),
);
write(&format!("ppt/slides/_rels/slide{}.xml.rels",i+1),br#"<Relationships><Relationship Id="legacy" Target="../media/shared.mp4" Type="example/video"/><Relationship Id="media" Target="../media/shared.mp4" Type="example/media"/><Relationship Id="external" Target="https://example.invalid" TargetMode="External" Type="example/video"/></Relationships>"#);
}
zip.finish().unwrap();
}
fn sample() -> Report {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("Review & plans.pptx");
deck(
&path,
&[
(
picture("2", r#"<p14:trim st="1s" end="2s"/>"#),
timing("2", r#"dur="indefinite""#),
),
(picture("2", ""), timing("2", r#"repeatCount="indefinite""#)),
(picture("2", ""), timing("2", r#"spd="200000""#)),
],
true,
);
let mut zip = zip::ZipArchive::new(File::open(&path).unwrap()).unwrap();
let d = archive::discover(&mut zip);
let video = Video {
slides: vec![1, 2, 3],
duration_seconds: Some(10.0),
name: "shared <clip> #1.mp4".into(),
size_bytes: 1234,
resolution: "32×24".into(),
codec: "mpeg4".into(),
archive_path: "ppt/media/shared.mp4".into(),
extracted_file: Some("../videos/shared <clip> #1.mp4".into()),
};
engine::assemble(&path, vec![video], &d)
}
#[test]
fn trims_and_loops_have_distinct_occurrences() {
let r = sample();
assert_eq!(r.embedded_videos, 1);
assert_eq!(r.playbacks.len(), 3);
assert_eq!(r.total_duration_seconds, 7.0);
assert_eq!(r.total_media_duration_seconds, 10.0);
assert_eq!(r.playbacks[0].settings.playback_status, "trimmed");
assert_eq!(r.playbacks[1].settings.playback_status, "looping");
assert_eq!(r.playbacks[2].settings.playback_status, "custom-timing");
let ontime = reports::ontime(&r);
let events = ontime["rundowns"]["default"]["entries"]
.as_object()
.unwrap();
assert_eq!(events.len(), 1);
assert_eq!(events.values().next().unwrap()["duration"], 7000);
}
#[test]
fn units_and_unsafe_trim_values() {
for (s, expected) in [
("1500", 1.5),
("1.25s", 1.25),
("1min", 60.0),
("0.5h", 1800.0),
("250ms", 0.25),
("1000µs", 0.001),
("1000μs", 0.001),
("1000000ns", 0.001),
] {
assert_eq!(playback::time_offset(s), Some(expected));
}
for s in [
"-1", "NaN", "Infinity", "1:30", "2seconds", "", ".2", "2.", "1.2.3",
] {
assert_eq!(playback::time_offset(s), None);
}
let video = Video {
duration_seconds: Some(10.0),
..Default::default()
};
let settings = Settings {
trim_start_seconds: 10.0,
..Default::default()
};
let p = playback::effective(&video, settings);
assert_eq!(p.settings.playback_status, "invalid-trim");
assert!(!p.ontime_eligible);
let p = playback::effective(&Video::default(), Settings::default());
assert_eq!(p.settings.playback_status, "unknown");
assert!(p.ontime_eligible);
}
#[test]
fn invalid_custom_inherited_and_unrelated_timing() {
let relationships = [
(
"media".into(),
(Some("part".into()), "example/media".into()),
),
(
"legacy".into(),
(Some("part".into()), "example/video".into()),
),
]
.into();
for (trim, animation, status) in [
(
r#"<p14:trim st="-1"/>"#.to_string(),
String::new(),
"invalid-trim",
),
(
r#"<p14:trim st="1s"/><p14:trim st="2s"/>"#.into(),
String::new(),
"invalid-trim",
),
(
String::new(),
timing("2", r#"autoRev="1""#),
"custom-timing",
),
(String::new(), timing("2", r#"dur="3000""#), "custom-timing"),
(
String::new(),
timing("2", r#"repeatCount="2000""#),
"looping",
),
(
String::new(),
format!(
r#"<p:par><p:cTn repeatCount="indefinite"><p:childTnLst>{}</p:childTnLst></p:cTn></p:par>"#,
timing("2", "")
),
"looping",
),
(
String::new(),
timing("99", r#"repeatCount="indefinite""#),
"normal",
),
] {
let xml = slide(&picture("2", &trim), &animation);
let doc = roxmltree::Document::parse(&xml).unwrap();
let settings = playback::shape_settings(&doc, &relationships, &["part".into()], 1);
assert_eq!(settings.len(), 1);
assert_eq!(settings[0].1.playback_status, status);
}
}
#[test]
fn all_reports_escape_content_and_keep_readable_trim_loop_annotations() {
let r = sample();
for format in FORMATS {
assert!(!reports::render(&r, format).unwrap().is_empty());
}
let html = reports::html(&r);
assert!(html.contains("shared &lt;clip&gt; #1.mp4"));
assert!(html.contains("../videos/shared%20%3Cclip%3E%20%231.mp4"));
assert!(html.contains("Trim removed"));
assert!(html.contains(">Looping</span>"));
let dense = reports::typst(&r, true);
assert!(dense.contains("flipped: false"));
assert!(!dense.contains("Embedded videos"));
assert!(dense.contains("Looping"));
assert!(dense.contains("Trim removed"));
for markdown in [true, false] {
let text = reports::text(&r, markdown);
let widths: Vec<_> = text
.lines()
.filter(|l| l.starts_with('|'))
.map(|s| s.chars().count())
.collect();
assert!(widths.iter().all(|w| *w == widths[0]));
assert!(text.contains("00:00:07.000"));
assert!(text.contains("Trim removed"));
}
assert_eq!(reports::time(None), "Unknown");
assert_eq!(reports::time(Some(3661.125)), "01:01:01.125");
assert_eq!(reports::size(1024), "1.00 KiB");
assert_eq!(reports::size(4), "4 B");
assert_eq!(reports::escape("<&>\"'"), "&lt;&amp;&gt;&quot;&#39;");
assert_eq!(reports::typst_string("a\n\"\\#"), "\"a\\u{a}\\\"\\\\#\"");
assert!(reports::render(&r, "bad").is_err());
}
#[test]
fn format_options_and_probe_errors() {
assert_eq!(formats(&["all,md".into()]).unwrap().len(), 8);
assert_eq!(formats(&[" JSON,md ".into()]).unwrap(), vec!["json", "md"]);
assert!(formats(&["html,".into()]).is_err());
assert!(Options::default().validate().is_err());
assert!(engine::find_ffprobe(Some(Path::new("/missing/probe"))).is_err());
assert_eq!(engine::probe_json(b"broken").0, None);
assert_eq!(
engine::probe_json(br#"{"format":{"duration":"NaN"}}"#).0,
None
);
let p = engine::probe_json(br#"{"format":{"duration":"1.25"},"streams":[{"codec_type":"audio"},{"codec_type":"video","width":32,"height":24,"codec_name":"mpeg4"}]}"#);
assert_eq!(p, (Some(1.25), "32×24".into(), "mpeg4".into()));
assert_eq!(
archive::normalize("ppt/slides/slide1.xml", "../media/foo.mp4#thing"),
"ppt/media/foo.mp4"
);
assert_eq!(
archive::normalize("ppt/slides/slide1.xml", "/ppt/media/foo.mp4?x"),
"ppt/media/foo.mp4"
);
assert!(!archive::is_video("foo.mp3"));
assert!(archive::is_video("foo.MP4"));
}
#[test]
fn empty_extract_only_and_cancelled_runs() {
let dir = tempfile::tempdir().unwrap();
let source = dir.path().join("test.pptx");
deck(&source, &[], false);
let mut options = Options {
source: source.clone(),
..Default::default()
};
let outcome = engine::run(&options, &AtomicBool::new(false), |_| {}).unwrap();
assert!(outcome.paths.is_empty());
assert!(!options.output_dir().exists());
deck(&source, &[], true);
options.extract_only = true;
let outcome = engine::run(&options, &AtomicBool::new(false), |_| {}).unwrap();
let media = outcome.output.join("videos/shared.mp4");
assert_eq!(fs::read(&media).unwrap(), b"video");
fs::write(&media, b"preserved").unwrap();
engine::run(&options, &AtomicBool::new(false), |_| {}).unwrap();
assert_eq!(fs::read(&media).unwrap(), b"preserved");
options.overwrite = true;
engine::run(&options, &AtomicBool::new(false), |_| {}).unwrap();
assert_eq!(fs::read(&media).unwrap(), b"video");
assert!(engine::run(&options, &AtomicBool::new(true), |_| {}).is_err());
options.timings_only = true;
assert!(options.validate().is_err());
}
#[test]
fn fallback_orphans_unknown_durations_and_external_links() {
let mut discovery = archive::Discovery::default();
discovery.external.insert(3);
let r = engine::assemble(
Path::new("orphan.pptx"),
vec![Video {
name: "orphan.mp4".into(),
..Default::default()
}],
&discovery,
);
assert_eq!(r.playbacks.len(), 1);
let project = reports::ontime(&r);
let event = project["rundowns"]["default"]["entries"]
.as_object()
.unwrap()
.values()
.next()
.unwrap();
assert_eq!(event["skip"], true);
assert_eq!(event["cue"], "Unreferenced");
assert!(
project["project"]["description"]
.as_str()
.unwrap()
.contains("slides: 3")
);
assert!(reports::html(&r).contains("external media links: 3"));
assert!(reports::typst(&r, false).contains("Unknown"));
}
#[cfg(feature = "pdf")]
#[test]
fn both_pdf_layouts_compile_offline() {
for dense in [true, false] {
let bytes = pptx_reporter::pdf::compile(&reports::typst(&sample(), dense)).unwrap();
assert!(bytes.starts_with(b"%PDF-"));
}
assert!(pptx_reporter::pdf::compile("#read(\"/etc/passwd\")").is_err());
}
#[cfg(feature = "desktop")]
#[test]
fn gui_drop_and_recent_files() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("test.PPTX");
fs::write(&path, b"").unwrap();
assert_eq!(
pptx_reporter::gui::accept_drop([path.clone()]).unwrap(),
path
);
assert!(pptx_reporter::gui::accept_drop([]).is_err());
assert!(pptx_reporter::gui::accept_drop([path.clone(), path.clone()]).is_err());
assert!(pptx_reporter::gui::accept_drop([dir.path().join("test.pdf")]).is_err());
let mut prefs = pptx_reporter::gui::Preferences::default();
for i in 0..10 {
prefs.remember(format!("{i}.pptx").into());
}
prefs.remember("5.pptx".into());
assert_eq!(prefs.recent.len(), 8);
assert_eq!(prefs.recent[0], Path::new("5.pptx"));
}
#[test]
fn presentation_order_overrides_slide_filenames_and_tracks_external_links() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("ordered.pptx");
deck(&path, &[(picture("2", ""), String::new())], true);
let file = fs::OpenOptions::new()
.read(true)
.write(true)
.open(&path)
.unwrap();
let mut zip = zip::ZipWriter::new_append(file).unwrap();
let mut add = |name: &str, body: &str| {
zip.start_file(name, SimpleFileOptions::default()).unwrap();
zip.write_all(body.as_bytes()).unwrap();
};
add(
"ppt/presentation.xml",
&format!(
r#"<p:presentation xmlns:p="{}" xmlns:r="{}"><p:sldIdLst><p:sldId r:id="first"/><p:sldId r:id="second"/></p:sldIdLst></p:presentation>"#,
archive::P,
archive::R
),
);
add(
"ppt/_rels/presentation.xml.rels",
r#"<Relationships><Relationship Id="first" Target="slides/slide12.xml"/><Relationship Id="second" Target="slides/slide1.xml"/></Relationships>"#,
);
add(
"ppt/slides/slide12.xml",
&slide(r#"<a:videoFile r:link="remote"/>"#, ""),
);
add(
"ppt/slides/_rels/slide12.xml.rels",
r#"<Relationships><Relationship Id="remote" Target="https://example.invalid/clip.mp4" TargetMode="External" Type="example/video"/></Relationships>"#,
);
zip.finish().unwrap();
let mut zip = zip::ZipArchive::new(File::open(path).unwrap()).unwrap();
assert_eq!(
archive::slides(&mut zip),
["ppt/slides/slide12.xml", "ppt/slides/slide1.xml"]
);
let found = archive::discover(&mut zip);
assert_eq!(
found.uses["ppt/media/shared.mp4"]
.iter()
.copied()
.collect::<Vec<_>>(),
[2]
);
assert_eq!(found.external.iter().copied().collect::<Vec<_>>(), [1]);
}
#[test]
fn cli_help_invalid_options_and_empty_deck() {
use std::process::Command;
let exe = env!("CARGO_BIN_EXE_pptx-reporter");
let help = Command::new(exe).arg("--help").output().unwrap();
assert!(help.status.success());
assert!(String::from_utf8_lossy(&help.stdout).contains("--timings-only"));
assert!(
!Command::new(exe)
.args(["missing.pptx", "--report", "wrong"])
.output()
.unwrap()
.status
.success()
);
assert!(
!Command::new(exe)
.args(["missing.pptx", "--timings-only", "--extract-only"])
.output()
.unwrap()
.status
.success()
);
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("empty.pptx");
deck(&path, &[], false);
let output = Command::new(exe).arg(&path).output().unwrap();
assert!(output.status.success());
assert!(String::from_utf8_lossy(&output.stdout).contains("No embedded videos"));
assert!(!String::from_utf8_lossy(&output.stdout).contains('\u{1b}'));
assert!(!dir.path().join("empty_videos").exists());
}
#[cfg(unix)]
#[test]
fn engine_probes_temporaries_generates_reports_and_handles_failure() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
let source = dir.path().join("test.pptx");
deck(
&source,
&[(picture("2", r#"<p14:trim st="1s"/>"#), String::new())],
true,
);
let probe = dir.path().join("ffprobe");
fs::write(
&probe,
"#!/bin/sh\nprintf '%s' '{\"format\":{\"duration\":\"10\"},\"streams\":[]}'\n",
)
.unwrap();
fs::set_permissions(&probe, fs::Permissions::from_mode(0o755)).unwrap();
let mut options = Options {
source,
timings_only: true,
ffprobe: Some(probe.clone()),
formats: formats(&["all".into()]).unwrap(),
..Default::default()
};
#[cfg(not(feature = "pdf"))]
options.formats.retain(|f| f != "pdf" && f != "pdf-dense");
let outcome = engine::run(&options, &AtomicBool::new(false), |_| {}).unwrap();
assert!(!outcome.output.join("videos").exists());
assert_eq!(outcome.report.unwrap().total_duration_seconds, 9.0);
assert!(outcome.output.join("reports/timings.ontime.json").is_file());
options.timings_only = false;
engine::run(&options, &AtomicBool::new(false), |_| {}).unwrap();
assert_eq!(
fs::read(outcome.output.join("videos/shared.mp4")).unwrap(),
b"video"
);
fs::write(&probe, "#!/bin/sh\nexit 1\n").unwrap();
assert_eq!(
engine::probe(&probe, Path::new("any"), &AtomicBool::new(false))
.unwrap()
.0,
None
);
assert!(engine::probe(&probe, Path::new("any"), &AtomicBool::new(true)).is_err());
}