use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use crate::process;
use crate::{
Adapter, Artifact, BackendStatus, Conversion, ConversionFuture, ConversionKind, Error, Format,
MediaKind, Result, StepRequest,
};
const VIDEO: &[(&str, &str)] = &[
("mp4", "MPEG-4 video"),
("mkv", "Matroska video"),
("avi", "AVI video"),
("webm", "WebM video"),
("mov", "QuickTime video"),
("mpg", "MPEG video"),
];
const AUDIO: &[&str] = &["wav", "mp3", "flac", "aac", "ogg", "m4a"];
const FRAME_IMAGES: &[&str] = &["png", "jpeg", "gif", "bmp"];
const RASTER_IMAGES: &[&str] = &[
"png", "jpeg", "gif", "webp", "tiff", "bmp", "pnm", "tga", "ico", "dds", "qoi", "hdr",
"farbfeld",
];
const OFFICE: &[(&str, &str)] = &[
("doc", "Microsoft Word document"),
("docx", "Office Open XML document"),
("odt", "OpenDocument text"),
("rtf", "Rich Text Format document"),
("xls", "Microsoft Excel workbook"),
("xlsx", "Office Open XML workbook"),
("ods", "OpenDocument spreadsheet"),
("ppt", "Microsoft PowerPoint presentation"),
("pptx", "Office Open XML presentation"),
("odp", "OpenDocument presentation"),
("html", "HTML document"),
];
const OFFICE_FAMILIES: &[&[&str]] = &[
&["doc", "docx", "odt", "rtf", "html"],
&["xls", "xlsx", "ods"],
&["ppt", "pptx", "odp"],
];
pub async fn discover() -> Vec<Arc<dyn Adapter>> {
let mut adapters: Vec<Arc<dyn Adapter>> = Vec::new();
if process::available("ffmpeg").await {
adapters.push(Arc::new(FfmpegAdapter));
}
if process::available("convert").await {
adapters.push(Arc::new(ImageMagickAdapter));
}
let pdftotext = process::available("pdftotext").await;
let pdftoppm = process::available("pdftoppm").await;
if pdftotext || pdftoppm {
adapters.push(Arc::new(PopplerAdapter {
pdftotext,
pdftoppm,
}));
}
if process::available("soffice").await {
adapters.push(Arc::new(SofficeAdapter));
}
if process::available("inkscape").await {
adapters.push(Arc::new(InkscapeAdapter));
}
adapters
}
struct FfmpegAdapter;
impl Adapter for FfmpegAdapter {
fn name(&self) -> &str {
"ffmpeg"
}
fn formats(&self) -> Vec<Format> {
let mut formats = VIDEO
.iter()
.map(|(id, name)| Format::new(id, name, MediaKind::Video).with_extensions(&[id]))
.collect::<Vec<_>>();
formats.extend(AUDIO.iter().map(|id| Format::new(id, id, MediaKind::Audio)));
formats.extend(
FRAME_IMAGES
.iter()
.map(|id| Format::new(id, id, MediaKind::Image)),
);
formats
}
fn conversions(&self) -> Vec<Conversion> {
let mut edges = Vec::new();
for from in AUDIO {
for to in AUDIO {
if from != to {
edges.push(external_edge(
from,
to,
"ffmpeg-transcode",
ConversionKind::Lossy,
30,
));
}
}
}
for (from, _) in VIDEO {
for (to, _) in VIDEO {
if from != to {
edges.push(external_edge(
from,
to,
"ffmpeg-transcode",
ConversionKind::Lossy,
35,
));
}
}
for to in AUDIO {
edges.push(external_edge(
from,
to,
"ffmpeg-audio",
ConversionKind::Lossy,
35,
));
}
for to in FRAME_IMAGES {
edges.push(external_edge(
from,
to,
"ffmpeg-frame",
ConversionKind::Lossy,
40,
));
}
}
for from in ["png", "jpeg"] {
for (to, _) in VIDEO {
edges.push(external_edge(
from,
to,
"ffmpeg-still",
ConversionKind::Bridge,
55,
));
}
}
edges
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
let input = one_input(request)?;
let output = output_path(request, &request.to);
let input_name = path_string(&input.path);
let output_name = path_string(&output);
let mut args = vec![
"-hide_banner".into(),
"-loglevel".into(),
"error".into(),
"-nostdin".into(),
"-y".into(),
];
match request.operation.as_str() {
"ffmpeg-transcode" => {
args.extend(["-i".into(), input_name]);
if request.to == "mpg" {
args.extend(["-r".into(), "25".into()]);
}
args.push(output_name);
}
"ffmpeg-audio" => {
args.extend(["-i".into(), input_name, "-vn".into(), output_name]);
}
"ffmpeg-frame" => {
args.extend([
"-i".into(),
input_name,
"-map".into(),
"0:v:0".into(),
"-frames:v".into(),
"1".into(),
output_name,
]);
}
"ffmpeg-still" => {
args.extend([
"-loop".into(),
"1".into(),
"-i".into(),
input_name,
"-t".into(),
"1".into(),
"-r".into(),
if request.to == "mpg" {
"25".into()
} else {
"1".into()
},
"-pix_fmt".into(),
"yuv420p".into(),
output_name,
]);
}
other => return Err(Error::Invalid(format!("unknown ffmpeg operation: {other}"))),
}
process::run("ffmpeg", "ffmpeg", &args, None, &request.limits).await?;
artifact_if_regular(output, &request.to, &request.limits)
})
}
}
struct ImageMagickAdapter;
impl Adapter for ImageMagickAdapter {
fn name(&self) -> &str {
"imagemagick"
}
fn formats(&self) -> Vec<Format> {
let mut formats = RASTER_IMAGES
.iter()
.map(|id| Format::new(id, id, MediaKind::Image))
.collect::<Vec<_>>();
formats.extend([
Format::new("exr", "OpenEXR image", MediaKind::Image).with_extensions(&["exr"]),
Format::new("psd", "Photoshop document", MediaKind::Image).with_extensions(&["psd"]),
]);
formats
}
fn conversions(&self) -> Vec<Conversion> {
let mut edges = Vec::new();
for source in ["exr", "psd"] {
for target in RASTER_IMAGES {
edges.push(external_edge(
source,
target,
"image-transcode",
ConversionKind::Lossy,
45,
));
}
}
for source in RASTER_IMAGES {
for target in ["exr", "psd"] {
edges.push(external_edge(
source,
target,
"image-transcode",
ConversionKind::Lossy,
45,
));
}
}
edges
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
if request.operation != "image-transcode" {
return Err(Error::Invalid(format!(
"unknown ImageMagick operation: {}",
request.operation
)));
}
let input = one_input(request)?;
let output = output_path(request, &request.to);
let args = vec![path_string(&input.path), path_string(&output)];
process::run("imagemagick", "convert", &args, None, &request.limits).await?;
artifact_if_regular(output, &request.to, &request.limits)
})
}
}
struct PopplerAdapter {
pdftotext: bool,
pdftoppm: bool,
}
impl Adapter for PopplerAdapter {
fn name(&self) -> &str {
"poppler"
}
fn formats(&self) -> Vec<Format> {
vec![
Format::new("pdf", "PDF document", MediaKind::Document),
Format::new("txt", "Plain text", MediaKind::Text),
Format::new("png", "PNG image", MediaKind::Image),
]
}
fn conversions(&self) -> Vec<Conversion> {
let mut edges = Vec::new();
if self.pdftotext {
edges.push(external_edge(
"pdf",
"txt",
"pdf-text",
ConversionKind::Bridge,
25,
));
}
if self.pdftoppm {
edges.push(external_edge(
"pdf",
"png",
"pdf-raster",
ConversionKind::Lossy,
30,
));
}
edges
}
fn status(&self) -> BackendStatus {
BackendStatus {
name: self.name().to_owned(),
available: self.pdftotext || self.pdftoppm,
detail: format!("pdftotext={}, pdftoppm={}", self.pdftotext, self.pdftoppm),
}
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
let input = one_input(request)?;
match request.operation.as_str() {
"pdf-text" if self.pdftotext => {
let output = output_path(request, "txt");
let args = vec![path_string(&input.path), path_string(&output)];
process::run("poppler", "pdftotext", &args, None, &request.limits).await?;
artifact_if_regular(output, "txt", &request.limits)
}
"pdf-raster" if self.pdftoppm => {
let output = output_path(request, "png");
let prefix = output.with_extension("");
let args = vec![
"-png".into(),
"-f".into(),
"1".into(),
"-l".into(),
"1".into(),
"-singlefile".into(),
path_string(&input.path),
path_string(&prefix),
];
process::run("poppler", "pdftoppm", &args, None, &request.limits).await?;
artifact_if_regular(output, "png", &request.limits)
}
other => Err(Error::Invalid(format!(
"unsupported or unavailable Poppler operation: {other}"
))),
}
})
}
}
struct SofficeAdapter;
impl Adapter for SofficeAdapter {
fn name(&self) -> &str {
"soffice"
}
fn formats(&self) -> Vec<Format> {
OFFICE
.iter()
.map(|(id, name)| Format::new(id, name, MediaKind::Document).with_extensions(&[id]))
.collect()
}
fn conversions(&self) -> Vec<Conversion> {
let mut edges = Vec::new();
for (source, _) in OFFICE {
edges.push(external_edge(
source,
"pdf",
"office-convert",
ConversionKind::Lossy,
70,
));
edges.push(external_edge(
source,
"txt",
"office-convert",
ConversionKind::Lossy,
95,
));
for family in OFFICE_FAMILIES {
if family.contains(source) {
for target in *family {
if source != target {
edges.push(external_edge(
source,
target,
"office-convert",
ConversionKind::Lossy,
90,
));
}
}
}
}
}
edges
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
if request.operation != "office-convert" {
return Err(Error::Invalid(format!(
"unknown LibreOffice operation: {}",
request.operation
)));
}
let input = one_input(request)?;
let profile = request.output_dir.join("soffice-profile");
let args = vec![
"--headless".into(),
profile_uri(&profile),
"--convert-to".into(),
extension_for(&request.to).into(),
"--outdir".into(),
path_string(&request.output_dir),
path_string(&input.path),
];
process::run("soffice", "soffice", &args, None, &request.limits).await?;
let output = move_office_output(request)?;
artifact_if_regular(output, &request.to, &request.limits)
})
}
}
struct InkscapeAdapter;
impl Adapter for InkscapeAdapter {
fn name(&self) -> &str {
"inkscape"
}
fn formats(&self) -> Vec<Format> {
vec![
Format::new("svg", "Scalable Vector Graphics", MediaKind::Image)
.with_extensions(&["svg"]),
Format::new("png", "PNG image", MediaKind::Image),
]
}
fn conversions(&self) -> Vec<Conversion> {
vec![external_edge(
"svg",
"png",
"svg-raster",
ConversionKind::Lossy,
35,
)]
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
if request.operation != "svg-raster" || request.to != "png" {
return Err(Error::Invalid(format!(
"unsupported Inkscape operation: {}",
request.operation
)));
}
let input = one_input(request)?;
let output = output_path(request, "png");
let args = vec![
path_string(&input.path),
"--export-filename".into(),
path_string(&output),
];
process::run("inkscape", "inkscape", &args, None, &request.limits).await?;
artifact_if_regular(output, "png", &request.limits)
})
}
}
fn external_edge(
from: &str,
to: &str,
operation: &str,
kind: ConversionKind,
cost: u32,
) -> Conversion {
Conversion::new(from, to, backend_for(operation), operation, kind, cost).requires_external()
}
fn backend_for(operation: &str) -> &'static str {
match operation {
"ffmpeg-transcode" | "ffmpeg-audio" | "ffmpeg-frame" | "ffmpeg-still" => "ffmpeg",
"image-transcode" => "imagemagick",
"pdf-text" | "pdf-raster" => "poppler",
"office-convert" => "soffice",
"svg-raster" => "inkscape",
_ => "external",
}
}
fn one_input(request: &StepRequest) -> Result<&Artifact> {
if request.inputs.len() != 1 {
return Err(Error::Invalid(
"external conversion requires one input".into(),
));
}
request
.inputs
.first()
.ok_or_else(|| Error::Invalid("external conversion input is missing".into()))
}
fn output_path(request: &StepRequest, format: &str) -> PathBuf {
request
.output_dir
.join(format!("external-0.{}", extension_for(format)))
}
fn extension_for(format: &str) -> &str {
match format {
"jpeg" => "jpg",
"tiff" => "tif",
"farbfeld" => "ff",
other => other,
}
}
fn path_string(path: &Path) -> String {
path.to_string_lossy().into_owned()
}
fn profile_uri(path: &Path) -> String {
let mut encoded = String::new();
for byte in path.to_string_lossy().bytes() {
if byte.is_ascii_alphanumeric() || b"-._~/".contains(&byte) {
encoded.push(char::from(byte));
} else {
encoded.push_str(&format!("%{byte:02X}"));
}
}
format!("-env:UserInstallation=file://{encoded}")
}
fn artifact_if_regular(
path: PathBuf,
format: &str,
limits: &crate::Limits,
) -> Result<Vec<Artifact>> {
let metadata = fs::symlink_metadata(&path).map_err(|error| {
Error::Conversion(format!("external tool did not produce output: {error}"))
})?;
if !metadata.file_type().is_file() {
return Err(Error::Security(
"external tool output is not a regular file".into(),
));
}
if metadata.len() > limits.max_output_bytes {
return Err(Error::Limit(
"external tool output exceeds byte budget".into(),
));
}
Ok(vec![Artifact {
path,
format: format.to_owned(),
}])
}
fn move_office_output(request: &StepRequest) -> Result<PathBuf> {
let extension = extension_for(&request.to);
let mut candidates = fs::read_dir(&request.output_dir)?
.filter_map(std::result::Result::ok)
.map(|entry| entry.path())
.filter(|path| {
fs::symlink_metadata(path).is_ok_and(|metadata| metadata.file_type().is_file())
&& path.extension().and_then(|value| value.to_str()) == Some(extension)
})
.collect::<Vec<_>>();
candidates.sort();
let source = candidates
.into_iter()
.next()
.ok_or_else(|| Error::Conversion("LibreOffice produced no expected output".into()))?;
let target = output_path(request, &request.to);
fs::rename(source, &target)?;
Ok(target)
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::Limits;
use std::time::Duration;
use tempfile::TempDir;
#[test]
fn external_edges_are_marked_external() {
let edge = external_edge("a", "b", "image-transcode", ConversionKind::Lossy, 1);
assert!(edge.external);
assert_eq!(edge.backend, "imagemagick");
}
#[test]
fn output_extensions_match_tool_conventions() {
assert_eq!(extension_for("jpeg"), "jpg");
assert_eq!(extension_for("png"), "png");
assert_eq!(extension_for("farbfeld"), "ff");
}
fn registered_format_ids(adapter: &dyn Adapter) -> Vec<String> {
adapter
.formats()
.iter()
.map(|format| format.id.clone())
.collect()
}
#[test]
fn every_edge_references_a_registered_format_and_backend() {
let adapters: Vec<Arc<dyn Adapter>> = vec![
Arc::new(FfmpegAdapter),
Arc::new(ImageMagickAdapter),
Arc::new(PopplerAdapter {
pdftotext: true,
pdftoppm: true,
}),
Arc::new(SofficeAdapter),
Arc::new(InkscapeAdapter),
];
for adapter in &adapters {
let ids = registered_format_ids(adapter.as_ref());
for edge in adapter.conversions() {
assert!(
ids.contains(&edge.from),
"{} edge {} -> {} starts from an unregistered format",
adapter.name(),
edge.from,
edge.to
);
assert_eq!(edge.backend, backend_for(&edge.operation));
assert!(edge.external);
assert!(edge.cost > 0);
}
}
}
#[test]
fn ffmpeg_edge_matrix_matches_format_products() {
let adapter = FfmpegAdapter;
let edges = adapter.conversions();
assert_eq!(edges.len(), 132);
let operations: Vec<&str> = edges.iter().map(|edge| edge.operation.as_str()).collect();
assert!(operations.contains(&"ffmpeg-transcode"));
assert!(operations.contains(&"ffmpeg-audio"));
assert!(operations.contains(&"ffmpeg-frame"));
assert!(operations.contains(&"ffmpeg-still"));
let format_ids = registered_format_ids(&adapter);
assert_eq!(format_ids.len(), 6 + 6 + 4);
assert!(format_ids.contains(&"mp4".to_owned()));
assert!(format_ids.contains(&"wav".to_owned()));
}
#[test]
fn imagemagick_edges_cross_exr_psd_boundary_only() {
let adapter = ImageMagickAdapter;
let edges = adapter.conversions();
assert_eq!(edges.len(), 52);
assert!(edges.iter().all(|edge| edge.from == "exr"
|| edge.from == "psd"
|| edge.to == "exr"
|| edge.to == "psd"));
assert_eq!(registered_format_ids(&adapter).len(), 15);
}
#[test]
fn soffice_edges_cover_pdf_txt_and_intra_family_pairs() {
let adapter = SofficeAdapter;
let edges = adapter.conversions();
assert_eq!(edges.len(), 54);
let intra_family = edges
.iter()
.filter(|edge| edge.to != "pdf" && edge.to != "txt")
.count();
assert_eq!(intra_family, 32);
for (source, _) in OFFICE {
assert!(
edges
.iter()
.any(|edge| edge.from == *source && edge.to == "pdf" && edge.cost == 70)
);
assert!(
edges
.iter()
.any(|edge| edge.from == *source && edge.to == "txt" && edge.cost == 95)
);
}
assert!(
!edges
.iter()
.any(|edge| edge.from == "docx" && edge.to == "xlsx")
);
assert!(
edges
.iter()
.any(|edge| edge.from == "docx" && edge.to == "odt")
);
}
#[test]
fn poppler_edges_follow_the_available_binaries() {
let both = PopplerAdapter {
pdftotext: true,
pdftoppm: true,
};
let edges = both.conversions();
assert_eq!(edges.len(), 2);
assert!(edges.iter().any(|edge| edge.operation == "pdf-text"));
assert!(edges.iter().any(|edge| edge.operation == "pdf-raster"));
let status = both.status();
assert!(status.available);
assert_eq!(status.detail, "pdftotext=true, pdftoppm=true");
let none = PopplerAdapter {
pdftotext: false,
pdftoppm: false,
};
assert!(none.conversions().is_empty());
assert!(!none.status().available);
assert_eq!(none.status().detail, "pdftotext=false, pdftoppm=false");
let text_only = PopplerAdapter {
pdftotext: true,
pdftoppm: false,
};
let edges = text_only.conversions();
assert_eq!(edges.len(), 1);
assert_eq!(edges[0].to, "txt");
}
#[test]
fn inkscape_formats_pair_svg_source_with_png_target() {
let adapter = InkscapeAdapter;
let ids = registered_format_ids(&adapter);
assert_eq!(ids, vec!["svg".to_owned(), "png".to_owned()]);
let edges = adapter.conversions();
assert_eq!(edges.len(), 1);
assert_eq!(
(edges[0].from.as_str(), edges[0].to.as_str()),
("svg", "png")
);
assert_eq!(edges[0].backend, "inkscape");
}
#[test]
fn backend_labels_cover_every_operation_family() {
assert_eq!(backend_for("ffmpeg-transcode"), "ffmpeg");
assert_eq!(backend_for("ffmpeg-audio"), "ffmpeg");
assert_eq!(backend_for("ffmpeg-frame"), "ffmpeg");
assert_eq!(backend_for("ffmpeg-still"), "ffmpeg");
assert_eq!(backend_for("image-transcode"), "imagemagick");
assert_eq!(backend_for("pdf-text"), "poppler");
assert_eq!(backend_for("pdf-raster"), "poppler");
assert_eq!(backend_for("office-convert"), "soffice");
assert_eq!(backend_for("svg-raster"), "inkscape");
assert_eq!(backend_for("mystery"), "external");
}
#[test]
fn profile_uri_encodes_reserved_path_bytes() {
let uri = profile_uri(Path::new("/tmp/a b/../prof"));
assert!(uri.starts_with("-env:UserInstallation=file:///tmp/a"));
assert!(uri.contains("%20"));
assert!(!uri.contains(' '));
}
#[test]
fn output_paths_use_stable_external_stems() {
let root = TempDir::new().unwrap();
let request = StepRequest {
inputs: Vec::new(),
output_dir: root.path().to_path_buf(),
from: "png".into(),
to: "tiff".into(),
operation: "x".into(),
limits: Limits::default(),
};
assert_eq!(
output_path(&request, "tiff"),
root.path().join("external-0.tif")
);
}
#[test]
fn one_input_rejects_wrong_cardinality() {
let root = TempDir::new().unwrap();
let artifact = |name: &str| Artifact {
path: root.path().join(name),
format: "bin".into(),
};
let empty = StepRequest {
inputs: vec![],
output_dir: root.path().to_path_buf(),
from: "bin".into(),
to: "mp4".into(),
operation: "ffmpeg-transcode".into(),
limits: Limits::default(),
};
assert!(matches!(one_input(&empty), Err(Error::Invalid(_))));
let double = StepRequest {
inputs: vec![artifact("a"), artifact("b")],
..empty
};
assert!(matches!(one_input(&double), Err(Error::Invalid(_))));
let single = StepRequest {
inputs: vec![artifact("a")],
..double
};
assert_eq!(one_input(&single).unwrap().path, root.path().join("a"));
}
#[test]
fn artifact_validation_enforces_regular_file_and_budget() {
let root = TempDir::new().unwrap();
let missing = root.path().join("missing.bin");
let error = artifact_if_regular(missing, "bin", &Limits::default()).unwrap_err();
assert!(matches!(error, Error::Conversion(_)), "{error:?}");
let directory = root.path().join("subdir");
fs::create_dir(&directory).unwrap();
let error = artifact_if_regular(directory, "bin", &Limits::default()).unwrap_err();
assert!(matches!(error, Error::Security(_)), "{error:?}");
#[cfg(unix)]
{
let target = root.path().join("target.bin");
fs::write(&target, b"x").unwrap();
let link = root.path().join("link.bin");
std::os::unix::fs::symlink(&target, &link).unwrap();
let ok = artifact_if_regular(link, "bin", &Limits::default());
assert!(
matches!(ok, Err(Error::Security(_))),
"symlink must be rejected"
);
}
let big = root.path().join("big.bin");
fs::write(&big, vec![7u8; 4096]).unwrap();
let tight = Limits {
max_output_bytes: 16,
..Limits::default()
};
let error = artifact_if_regular(big.clone(), "bin", &tight).unwrap_err();
assert!(matches!(error, Error::Limit(_)), "{error:?}");
fs::remove_file(&big).unwrap();
fs::write(&big, b"payload").unwrap();
let artifacts = artifact_if_regular(big, "bin", &Limits::default()).unwrap();
assert_eq!(artifacts.len(), 1);
assert_eq!(artifacts[0].format, "bin");
}
#[test]
fn move_office_output_renames_the_first_sorted_candidate() {
let root = TempDir::new().unwrap();
fs::write(root.path().join("zeta.pdf"), b"b").unwrap();
fs::write(root.path().join("alpha.pdf"), b"a").unwrap();
fs::write(root.path().join("ignore.txt"), b"t").unwrap();
fs::create_dir(root.path().join("nested.pdf")).unwrap();
let request = StepRequest {
inputs: Vec::new(),
output_dir: root.path().to_path_buf(),
from: "docx".into(),
to: "pdf".into(),
operation: "office-convert".into(),
limits: Limits::default(),
};
let moved = move_office_output(&request).unwrap();
assert_eq!(moved, root.path().join("external-0.pdf"));
assert_eq!(fs::read(&moved).unwrap(), b"a");
assert!(root.path().join("zeta.pdf").is_file());
let root = TempDir::new().unwrap();
let request = StepRequest {
output_dir: root.path().to_path_buf(),
..request
};
let error = move_office_output(&request).unwrap_err();
assert!(matches!(error, Error::Conversion(_)), "{error:?}");
}
fn request(
adapter_input: PathBuf,
output_dir: &Path,
from: &str,
to: &str,
operation: &str,
) -> StepRequest {
StepRequest {
inputs: vec![Artifact {
path: adapter_input,
format: from.into(),
}],
output_dir: output_dir.to_path_buf(),
from: from.into(),
to: to.into(),
operation: operation.into(),
limits: Limits {
timeout: Duration::from_secs(20),
..Limits::default()
},
}
}
#[tokio::test]
async fn unknown_operations_fail_before_spawning_tools() {
let root = TempDir::new().unwrap();
fs::write(root.path().join("in.bin"), b"x").unwrap();
let adapters: Vec<&dyn Adapter> = vec![
&FfmpegAdapter,
&ImageMagickAdapter,
&SofficeAdapter,
&InkscapeAdapter,
];
for adapter in adapters {
let wrong = request(
root.path().join("in.bin"),
root.path(),
"bin",
"png",
"bogus-operation",
);
let error = adapter.convert(&wrong).await.unwrap_err();
assert!(
matches!(error, Error::Invalid(_)),
"{}: {error:?}",
adapter.name()
);
}
}
#[tokio::test]
async fn inkscape_requires_svg_to_png_and_reports_missing_output() {
let root = TempDir::new().unwrap();
fs::write(root.path().join("in.svg"), b"<svg/>").unwrap();
let adapter = InkscapeAdapter;
let wrong_target = request(
root.path().join("in.svg"),
root.path(),
"svg",
"jpeg",
"svg-raster",
);
assert!(matches!(
adapter.convert(&wrong_target).await.unwrap_err(),
Error::Invalid(_)
));
}
#[tokio::test]
async fn poppler_refuses_operations_for_absent_binaries() {
let root = TempDir::new().unwrap();
fs::write(root.path().join("in.pdf"), b"%PDF-1.4\n").unwrap();
let adapter = PopplerAdapter {
pdftotext: false,
pdftoppm: true,
};
let error = adapter
.convert(&request(
root.path().join("in.pdf"),
root.path(),
"pdf",
"txt",
"pdf-text",
))
.await
.unwrap_err();
assert!(matches!(error, Error::Invalid(_)), "{error:?}");
}
#[tokio::test]
async fn discovery_returns_unique_adapters_for_installed_tools() {
let adapters = discover().await;
let valid = ["ffmpeg", "imagemagick", "poppler", "soffice", "inkscape"];
let mut names: Vec<&str> = adapters.iter().map(|adapter| adapter.name()).collect();
for name in &names {
assert!(valid.contains(name), "unexpected adapter {name}");
}
names.sort_unstable();
names.dedup();
assert_eq!(names.len(), adapters.len());
}
#[tokio::test]
async fn ffmpeg_audio_transcode_runs_when_the_tool_is_present() {
if !process::available("ffmpeg").await {
return;
}
let root = TempDir::new().unwrap();
let input = root.path().join("tone.wav");
let spec = hound::WavSpec {
channels: 1,
sample_rate: 8_000,
bits_per_sample: 16,
sample_format: hound::SampleFormat::Int,
};
let mut writer = hound::WavWriter::create(&input, spec).unwrap();
for sample in 0..8_000 {
writer.write_sample((sample as i16 >> 3) - 2_000).unwrap();
}
writer.finalize().unwrap();
let adapter = FfmpegAdapter;
let report = adapter
.convert(&request(
input,
root.path(),
"wav",
"mp3",
"ffmpeg-transcode",
))
.await;
assert!(report.is_ok(), "{report:?}");
let artifacts = report.unwrap();
assert_eq!(artifacts[0].format, "mp3");
assert!(artifacts[0].path.is_file());
}
#[tokio::test]
async fn soffice_converts_a_real_document_and_renames_output() {
if !process::available("soffice").await {
return;
}
let root = TempDir::new().unwrap();
let input = root.path().join("note.docx");
let xml = document();
fs::write(&input, xml).unwrap();
let adapter = SofficeAdapter;
let result = adapter
.convert(&request(
input,
root.path(),
"docx",
"txt",
"office-convert",
))
.await;
assert!(result.is_ok(), "{result:?}");
let artifacts = result.unwrap();
assert_eq!(artifacts[0].path, root.path().join("external-0.txt"));
}
fn document() -> String {
r#"<?xml version="1.0" encoding="UTF-8"?>
<office:document xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" office:version="1.2" office:mimetype="application/vnd.oasis.opendocument.text"><office:body><office:text><text:p>EXTERNAL UNIT MARKER</text:p></office:text></office:body></office:document>"#.to_owned()
}
}