#![allow(
clippy::err_expect,
clippy::expect_used,
clippy::unwrap_used,
clippy::field_reassign_with_default,
clippy::new_ret_no_self
)]
use std::collections::BTreeSet;
use std::fs;
use std::sync::Arc;
use std::time::Duration;
use convert_rs::{
Adapter, Artifact, ContentKind, ContentProfile, Conversion, ConversionFuture, ConversionKind,
ConversionOptions, Converter, Error, Format, IdentificationMethod, Limits, MediaKind, Plan,
Policy, ProfileSource, StepRequest,
};
use tempfile::TempDir;
const SHARED_IDS: &[&str] = &["bin", "txt"];
struct Scripted {
name: String,
kinds: Vec<(&'static str, &'static str, &'static str)>,
}
impl Scripted {
fn new(name: &str, kinds: Vec<(&'static str, &'static str, &'static str)>) -> Arc<dyn Adapter> {
Arc::new(Self {
name: name.to_owned(),
kinds,
})
}
}
impl Adapter for Scripted {
fn name(&self) -> &str {
&self.name
}
fn param_keys(&self, operation: &str) -> Vec<String> {
if operation == "copy" {
vec!["quality".to_owned()]
} else {
Vec::new()
}
}
fn formats(&self) -> Vec<Format> {
let mut ids = BTreeSet::new();
for (from, to, _) in &self.kinds {
ids.insert(*from);
ids.insert(*to);
}
let mut formats: Vec<Format> = ids
.into_iter()
.filter(|id| !SHARED_IDS.contains(id))
.map(|id| Format::new(id, id, MediaKind::Binary))
.collect();
if formats.is_empty() {
formats.push(Format::new(
&format!("{}-probe", self.name),
"Probe",
MediaKind::Binary,
));
}
formats
}
fn conversions(&self) -> Vec<Conversion> {
self.kinds
.iter()
.enumerate()
.map(|(index, (from, to, operation))| {
Conversion::new(
from,
to,
&self.name,
operation,
ConversionKind::Lossless,
index as u32 + 1,
)
})
.collect()
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
let backend = self.name.clone();
let request = request.clone();
match request.operation.as_str() {
"copy" => {
if request.limits.timeout.is_zero() {
return Err(Error::Timeout { backend });
}
let mut artifacts = Vec::new();
for (index, input) in request.inputs.iter().enumerate() {
let path = request
.output_dir
.join(format!("copied-{index}.{}", request.to));
fs::copy(&input.path, &path)?;
artifacts.push(Artifact::new(path, request.to.clone()));
}
Ok(artifacts)
}
"fail" => Err(Error::Conversion("scripted failure".into())),
"wrong-format" => {
let path = request.output_dir.join("wrong.txt");
fs::write(&path, b"payload")?;
Ok(vec![Artifact::new(path, "ghost")])
}
"escape" => {
let path = request
.output_dir
.parent()
.expect("workspace parent")
.join("escaped.bin");
fs::write(&path, b"payload")?;
Ok(vec![Artifact::new(path, request.to.clone())])
}
"missing" => Ok(vec![Artifact::new(
request.output_dir.join("never-written.bin"),
request.to.clone(),
)]),
"directory" => {
let path = request.output_dir.join("subdir");
fs::create_dir(&path)?;
Ok(vec![Artifact::new(path, request.to.clone())])
}
"oversize" => {
let path = request.output_dir.join("fat.bin");
let fill =
usize::try_from(request.limits.max_output_bytes + 1).expect("small budget");
fs::write(&path, vec![7u8; fill])?;
Ok(vec![Artifact::new(path, request.to.clone())])
}
"many" => {
let mut artifacts = Vec::new();
for index in 0..3 {
let path = request.output_dir.join(format!("many-{index}"));
fs::write(&path, b"x")?;
artifacts.push(Artifact::new(path, request.to.clone()));
}
Ok(artifacts)
}
"slow" => {
tokio::time::sleep(request.limits.timeout + Duration::from_millis(50)).await;
Err(Error::Timeout { backend })
}
other => Err(Error::Invalid(format!("unknown scripted op: {other}"))),
}
})
}
}
struct Empty;
impl Adapter for Empty {
fn name(&self) -> &str {
"empty"
}
fn formats(&self) -> Vec<Format> {
Vec::new()
}
fn conversions(&self) -> Vec<Conversion> {
Vec::new()
}
fn convert<'a>(&'a self, _request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async { Ok(vec![]) })
}
}
struct HugeFormats;
impl Adapter for HugeFormats {
fn name(&self) -> &str {
"huge-formats"
}
fn formats(&self) -> Vec<Format> {
(0..8193)
.map(|index| Format::new(&format!("fmt{index}"), "F", MediaKind::Binary))
.collect()
}
fn conversions(&self) -> Vec<Conversion> {
Vec::new()
}
fn convert<'a>(&'a self, _request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async { Ok(vec![]) })
}
}
struct BrokenEdges {
name: String,
}
impl Adapter for BrokenEdges {
fn name(&self) -> &str {
&self.name
}
fn formats(&self) -> Vec<Format> {
vec![Format::new("broken-probe", "Probe", MediaKind::Binary)]
}
fn conversions(&self) -> Vec<Conversion> {
vec![Conversion::new(
"txt",
"nowhere",
&self.name,
"copy",
ConversionKind::Lossless,
1,
)]
}
fn convert<'a>(&'a self, _request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async { Ok(vec![]) })
}
}
fn converter_with(adapters: Vec<Arc<dyn Adapter>>) -> Converter {
let mut converter = Converter::new();
for adapter in adapters {
converter.register(adapter).expect("register adapter");
}
converter
}
fn options() -> ConversionOptions {
ConversionOptions::default()
}
#[test]
fn registration_validates_names_and_shape() {
let rejections: Vec<(Arc<dyn Adapter>, &str)> = vec![
(
Scripted::new("", vec![("txt", "dest", "copy")]),
"invalid adapter name",
),
(
Scripted::new(&"x".repeat(65), vec![("txt", "dest", "copy")]),
"invalid adapter name",
),
(Arc::new(Empty), "adapter registration rejected"),
(Arc::new(HugeFormats), "adapter registration rejected"),
];
for (adapter, message) in rejections {
let mut converter = Converter::new();
let error = converter
.register(adapter)
.err()
.expect("rejected registration");
match error {
Error::Invalid(detail) => assert!(detail.contains(message), "{detail}"),
other => panic!("unexpected error: {other:?}"),
}
}
}
#[test]
fn failed_graph_rebuild_keeps_previous_registry_usable() {
let converter = converter_with(vec![Scripted::new(
"scripted",
vec![("txt", "dest", "copy")],
)]);
let mut converter = converter;
let broken: Arc<dyn Adapter> = Arc::new(BrokenEdges {
name: "scripted".into(),
});
assert!(matches!(converter.register(broken), Err(Error::Plan(_))));
assert!(
converter.plan("txt", "dest", converter.policy()).is_ok(),
"graph must be unchanged after a rejected registration"
);
assert_eq!(
converter
.backends()
.iter()
.filter(|status| status.name == "scripted")
.count(),
1
);
}
#[test]
fn default_status_names_the_adapter() {
let adapter = Scripted::new("no-status", vec![("txt", "dest", "copy")]);
let status = adapter.status();
assert_eq!(status.name, "no-status");
assert!(status.available);
assert!(status.detail.is_empty());
}
#[test]
fn accessors_report_registry_state() {
let converter = converter_with(vec![Scripted::new(
"scripted",
vec![("txt", "copyfmt", "copy")],
)]);
let debug = format!("{converter:?}");
assert!(debug.contains("Converter"), "{debug}");
assert!(debug.contains("scripted"), "{debug}");
assert!(
converter
.formats()
.iter()
.any(|format| format.id == "copyfmt")
);
assert_eq!(
converter.resolve(" COPYFMT ").expect("resolve").id,
"copyfmt"
);
assert!(converter.graph().format("copyfmt").is_some());
assert_eq!(converter.policy(), &Policy::default());
let names: Vec<String> = converter
.backends()
.iter()
.map(|status| status.name.clone())
.collect();
assert!(names.iter().any(|name| name == "scripted"), "{names:?}");
assert!(names.iter().any(|name| name == "builtin"), "{names:?}");
let policy = converter.policy().clone();
assert!(converter.plan("txt", "copyfmt", &policy).is_ok());
let limited = converter.limits(Limits {
max_artifacts: 3,
..Limits::default()
});
assert!(limited.plan("txt", "copyfmt", &policy).is_ok());
}
#[tokio::test]
async fn convert_argument_validation_is_early_and_precise() {
let converter = Converter::new();
assert!(matches!(
converter.convert(&[], "txt", &options()).await,
Err(Error::Invalid(_))
));
let root = TempDir::new().expect("tempdir");
let first = root.path().join("a.txt");
let second = root.path().join("b.txt");
fs::write(&first, b"one").unwrap();
fs::write(&second, b"two").unwrap();
let crowded = Converter::new().limits(Limits {
max_artifacts: 1,
..Limits::default()
});
assert!(matches!(
crowded
.convert(&[first.clone(), second], "txt", &options())
.await,
Err(Error::Limit(_))
));
let error = converter
.convert(std::slice::from_ref(&first), "nope", &options())
.await
.err()
.expect("unknown target");
assert!(
error.to_string().contains("unknown target format: nope"),
"{error}"
);
let bad_override = ConversionOptions {
from: Some("nope".into()),
..options()
};
let error = converter
.convert(std::slice::from_ref(&first), "txt", &bad_override)
.await
.err()
.expect("unknown source");
assert!(
error.to_string().contains("unknown source format"),
"{error}"
);
let override_copy = converter
.convert(
std::slice::from_ref(&first),
"txt",
&ConversionOptions {
from: Some("TXT".into()),
..options()
},
)
.await
.expect("override identity copy");
assert!(override_copy.plan.steps.is_empty());
assert!(override_copy.warnings.is_empty());
assert_eq!(
String::from_utf8_lossy(&fs::read(&override_copy.artifacts[0].path).unwrap()),
"one"
);
assert!(override_copy.directory().is_dir());
let artifact = override_copy.artifacts[0].path.clone();
drop(override_copy);
assert!(!artifact.exists(), "report drop must clean the workspace");
}
#[test]
fn identify_distinguishes_missing_symlink_and_extension_rules() {
let root = TempDir::new().expect("tempdir");
let converter = Converter::new();
assert!(matches!(
converter.identify(&root.path().join("missing")),
Err(Error::Invalid(_))
));
fs::write(root.path().join("note.TXt"), b"x").unwrap();
assert_eq!(
converter
.identify(&root.path().join("note.TXt"))
.expect("uppercase extension")
.method,
IdentificationMethod::Extension
);
fs::write(root.path().join("a.b.txt"), b"x").unwrap();
assert_eq!(
converter
.identify(&root.path().join("a.b.txt"))
.expect("multi-dot name")
.format,
"txt",
"multi-dot names must try every suffix, longest first"
);
fs::write(root.path().join("archive.unknownext.gz"), b"x").unwrap();
assert_eq!(
converter
.identify(&root.path().join("archive.unknownext.gz"))
.expect("nested suffix")
.format,
"gz",
"unknown inner suffixes fall through to the registered outer one"
);
#[cfg(unix)]
{
fs::write(root.path().join("target.txt"), b"x").unwrap();
std::os::unix::fs::symlink(root.path().join("target.txt"), root.path().join("link.txt"))
.expect("symlink");
assert!(matches!(
converter.identify(&root.path().join("link.txt")),
Err(Error::Security(_))
));
}
}
#[tokio::test]
async fn identification_rejects_empty_files_but_overrides_do_not() {
let root = TempDir::new().expect("tempdir");
let empty = root.path().join("empty.txt");
fs::write(&empty, b"").unwrap();
let converter = Converter::new();
assert!(matches!(
converter
.convert(std::slice::from_ref(&empty), "txt", &options())
.await,
Err(Error::Security(_))
));
let overridden = converter
.convert(
std::slice::from_ref(&empty),
"txt",
&ConversionOptions {
from: Some("txt".into()),
..options()
},
)
.await
.expect("override skips content identification");
assert_eq!(fs::read(&overridden.artifacts[0].path).unwrap().len(), 0);
}
#[tokio::test]
async fn backend_filter_selects_identity_and_rejects_the_rest() {
let converter = converter_with(vec![Scripted::new(
"scripted",
vec![("txt", "copyfmt", "copy")],
)]);
let root = TempDir::new().expect("tempdir");
let text = root.path().join("x.txt");
fs::write(&text, b"data").unwrap();
let pinned_identity = converter
.convert(
std::slice::from_ref(&text),
"txt",
&ConversionOptions {
backend: Some("whoever".into()),
..options()
},
)
.await
.expect("identity passes every backend filter");
assert!(pinned_identity.plan.steps.is_empty());
let pinned = converter
.convert(
std::slice::from_ref(&text),
"copyfmt",
&ConversionOptions {
from: Some("txt".into()),
backend: Some("scripted".into()),
..options()
},
)
.await
.expect("scripted route");
assert_eq!(pinned.plan.steps[0].backend, "scripted");
let error = converter
.convert(
std::slice::from_ref(&text),
"copyfmt",
&ConversionOptions {
from: Some("txt".into()),
backend: Some("nobody".into()),
..options()
},
)
.await
.err()
.expect("filtered route");
assert!(
error.to_string().contains("uses only backend nobody"),
"{error}"
);
}
fn forced(steps: Vec<Conversion>) -> ConversionOptions {
ConversionOptions {
forced_plan: Some(Plan::new(steps)),
..options()
}
}
fn step(from: &str, to: &str, backend: &str, operation: &str) -> Conversion {
Conversion::new(from, to, backend, operation, ConversionKind::Lossless, 1)
}
#[tokio::test]
async fn forced_plans_bypass_search_and_check_every_gate() {
let root = TempDir::new().expect("tempdir");
let text = root.path().join("in.txt");
fs::write(&text, b"data").unwrap();
let converter = converter_with(vec![Scripted::new(
"scripted",
vec![("txt", "txt", "copy")],
)]);
let ok = converter
.convert(
std::slice::from_ref(&text),
"txt",
&forced(vec![step("txt", "txt", "scripted", "copy")]),
)
.await
.expect("forced copy");
assert_eq!(ok.plan.steps.len(), 1);
let external = forced(vec![
step("txt", "txt", "scripted", "copy").requires_external(),
]);
let error = converter
.convert(std::slice::from_ref(&text), "txt", &external)
.await
.err()
.expect("external gate");
assert!(
error.to_string().contains("native external tool"),
"default policy must block external steps: {error}"
);
let kindless = forced(vec![
step("txt", "txt", "scripted", "copy").with_kind(ConversionKind::Package),
]);
let error = converter
.convert(std::slice::from_ref(&text), "txt", &kindless)
.await
.err()
.expect("kind gate");
assert!(error.to_string().contains("disabled"), "{error}");
let pinned_away = ConversionOptions {
backend: Some("builtin".into()),
..forced(vec![step("txt", "txt", "scripted", "copy")])
};
let error = converter
.convert(std::slice::from_ref(&text), "txt", &pinned_away)
.await
.err()
.expect("pin gate");
assert!(error.to_string().contains("disallowed backend"), "{error}");
let discont = forced(vec![step("bin", "txt", "scripted", "copy")]);
let error = converter
.convert(std::slice::from_ref(&text), "txt", &discont)
.await
.err()
.expect("continuity gate");
assert!(error.to_string().contains("expected bin inputs"), "{error}");
let ghost = forced(vec![step("txt", "txt", "not-registered", "copy")]);
let error = converter
.convert(std::slice::from_ref(&text), "txt", &ghost)
.await
.err()
.expect("backend existence gate");
assert!(error.to_string().contains("not registered"), "{error}");
let wrong_format = forced(vec![step("txt", "txt", "scripted", "wrong-format")]);
let error = converter
.convert(std::slice::from_ref(&text), "txt", &wrong_format)
.await
.err()
.expect("artifact format gate");
assert!(error.to_string().contains("for a txt step"), "{error}");
let target_miss = converter
.convert(
std::slice::from_ref(&text),
"bin",
&forced(vec![step("txt", "txt", "scripted", "copy")]),
)
.await
.err()
.expect("final format gate");
assert!(
target_miss.to_string().contains("do not match the target"),
"{target_miss}"
);
}
#[tokio::test]
async fn forced_multistep_and_external_opt_in_succeed() {
let root = TempDir::new().expect("tempdir");
let text = root.path().join("in.txt");
fs::write(&text, b"bytes").unwrap();
let converter = converter_with(vec![Scripted::new(
"scripted",
vec![("txt", "txt", "copy")],
)]);
let mut opened = converter;
opened.set_policy(Policy {
allow_external: true,
..Policy::default()
});
let report = opened
.convert(
std::slice::from_ref(&text),
"txt",
&forced(vec![
step("txt", "txt", "scripted", "copy").requires_external(),
step("txt", "txt", "scripted", "copy"),
]),
)
.await
.expect("external allowed forced route");
assert_eq!(report.plan.steps.len(), 2);
assert_eq!(
fs::read(&report.artifacts[0].path).unwrap(),
b"bytes".to_vec()
);
}
#[tokio::test]
async fn route_attempts_fall_back_until_one_succeeds() {
let root = TempDir::new().expect("tempdir");
let text = root.path().join("x.txt");
fs::write(&text, b"payload").unwrap();
let converter = converter_with(vec![Scripted::new(
"aafail",
vec![("txt", "dest", "fail"), ("txt", "dest", "copy")],
)]);
let report = converter
.convert(
std::slice::from_ref(&text),
"dest",
&ConversionOptions {
from: Some("txt".into()),
..options()
},
)
.await
.expect("second route attempt succeeds");
assert_eq!(report.plan.steps[0].operation, "copy");
assert_eq!(report.artifacts[0].format, "dest");
assert!(report.warnings.is_empty());
}
#[tokio::test]
async fn adapter_output_violations_surface_as_route_failures() {
let root = TempDir::new().expect("tempdir");
let text = root.path().join("x.txt");
fs::write(&text, b"payload").unwrap();
let converter = converter_with(vec![Scripted::new(
"scripted",
vec![
("txt", "dest", "escape"),
("txt", "dest", "missing"),
("txt", "dest", "directory"),
("txt", "dest", "many"),
("txt", "dest", "oversize"),
("txt", "dest", "slow"),
("txt", "dest", "fail"),
],
)])
.limits(Limits {
max_output_bytes: 8,
max_artifacts: 2,
timeout: Duration::from_millis(10),
..Limits::default()
});
let error = converter
.convert(
std::slice::from_ref(&text),
"dest",
&ConversionOptions {
from: Some("txt".into()),
..options()
},
)
.await
.err()
.expect("every behavior fails");
let detail = error.to_string();
for expected in [
"scripted failure",
"outside its step directory",
"does not exist",
"non-regular",
"too many artifacts",
"artifact bytes exceed",
"exceeded its timeout",
] {
assert!(
detail.contains(expected),
"missing {expected:?} in {detail}"
);
}
}
#[tokio::test]
async fn oversize_input_staging_fails_before_adapters_run() {
let root = TempDir::new().expect("tempdir");
let big = root.path().join("big.txt");
fs::write(&big, vec![b'x'; 64]).unwrap();
let converter = Converter::new().limits(Limits {
max_input_bytes: 32,
..Limits::default()
});
let error = converter
.convert(
std::slice::from_ref(&big),
"txt",
&ConversionOptions {
from: Some("txt".into()),
..options()
},
)
.await
.err()
.expect("staging limit");
assert!(
error.to_string().contains("input bytes exceed budget"),
"{error}"
);
}
#[tokio::test]
async fn warning_messages_cover_every_kind() {
let root = TempDir::new().expect("tempdir");
let text = root.path().join("x.txt");
fs::write(&text, b"data").unwrap();
let converter = converter_with(vec![Scripted::new(
"scripted",
vec![("txt", "txt", "copy")],
)]);
let converter = converter.with_policy(Policy {
allow_reinterpret: true,
allow_packaging: true,
..Policy::default()
});
for (kind, fragment) in [
(ConversionKind::Lossy, "re-encoded"),
(ConversionKind::Reencode, "in place"),
(ConversionKind::Bridge, "bridged"),
(ConversionKind::Reinterpret, "reinterpreted"),
(ConversionKind::Package, "packaged"),
(ConversionKind::Extract, "extracted"),
] {
let report = converter
.convert(
std::slice::from_ref(&text),
"txt",
&forced(vec![step("txt", "txt", "scripted", "copy").with_kind(kind)]),
)
.await
.unwrap_or_else(|error| panic!("{kind:?} step should execute: {error}"));
assert_eq!(report.warnings.len(), 1, "{kind:?}");
let warning = &report.warnings[0];
assert_eq!(warning.kind, kind);
assert_eq!(warning.step, 0);
assert_eq!(warning.backend, "scripted");
assert_eq!(warning.operation, "copy");
assert!(
warning.message.contains(fragment),
"{kind:?}: {}",
warning.message
);
}
let lossless = converter
.convert(
std::slice::from_ref(&text),
"txt",
&forced(vec![step("txt", "txt", "scripted", "copy")]),
)
.await
.expect("lossless forced step");
assert!(lossless.warnings.is_empty());
}
#[tokio::test]
async fn reencode_search_finds_same_format_route_and_reports_no_silent_copy() {
let root = TempDir::new().expect("tempdir");
let text = root.path().join("x.txt");
fs::write(&text, b"payload").unwrap();
let converter = converter_with(vec![Scripted::new("dup", vec![("txt", "txt", "copy")])]);
let report = converter
.convert(
std::slice::from_ref(&text),
"txt",
&ConversionOptions {
reencode: true,
..options()
},
)
.await
.expect("reencode request must find the same-format route");
assert!(
!report.plan.steps.is_empty(),
"identity copy must not answer a reencode request"
);
assert_eq!(fs::read(&report.artifacts[0].path).unwrap(), b"payload");
let plain = converter
.convert(
std::slice::from_ref(&text),
"txt",
&ConversionOptions {
backend: Some("dup".into()),
..options()
},
)
.await
.expect("same-format request without reencode still copies");
assert!(plain.plan.steps.is_empty());
let dead = converter_with(vec![Scripted::new(
"far",
vec![("txt", "somewhere", "copy")],
)]);
let error = dead
.convert(
std::slice::from_ref(&text),
"txt",
&ConversionOptions {
reencode: true,
..options()
},
)
.await
.err()
.expect("reencode with only a copy available must fail loudly");
assert!(
matches!(error, Error::Invalid(_)) && error.to_string().contains("reencode"),
"{error}"
);
}
#[tokio::test]
async fn preserve_prunes_search_and_enforces_forced_plans() {
let root = TempDir::new().expect("tempdir");
let source = root.path().join("a.ksrc");
fs::write(&source, b"payload").unwrap();
let keeper = converter_with(vec![Arc::new(Keeper {
retained: &["pixels"],
})]);
let matched = keeper
.convert(
std::slice::from_ref(&source),
"keeper-dst",
&ConversionOptions {
preserve: vec!["Pixels".into(), " pixels ".into()],
..options()
},
)
.await
.expect("declared retention satisfies the request");
assert_eq!(matched.plan.steps.len(), 1);
let pruned = keeper
.convert(
std::slice::from_ref(&source),
"keeper-dst",
&ConversionOptions {
preserve: vec!["alpha".into()],
..options()
},
)
.await
.err()
.expect("undeclared retention prunes the only route");
assert!(matches!(pruned, Error::Plan(_)), "{pruned}");
let stripped = converter_with(vec![Arc::new(Keeper { retained: &[] })]);
let pruned = stripped
.convert(
std::slice::from_ref(&source),
"keeper-dst",
&ConversionOptions {
preserve: vec!["pixels".into()],
..options()
},
)
.await
.err()
.expect("edge without the claim is pruned");
assert!(matches!(pruned, Error::Plan(_)), "{pruned}");
let text = root.path().join("note.txt");
fs::write(&text, b"payload").unwrap();
let identity = keeper
.convert(
std::slice::from_ref(&text),
"txt",
&ConversionOptions {
preserve: vec!["anything".into()],
..options()
},
)
.await
.expect("the byte-for-byte copy satisfies every retention request");
assert!(identity.plan.steps.is_empty());
let error = keeper
.convert(
std::slice::from_ref(&text),
"txt",
&ConversionOptions {
forced_plan: Some(Plan::new(vec![step("txt", "txt", "scripted", "copy")])),
preserve: vec!["metadata".into()],
..options()
},
)
.await
.err()
.expect("forced plans are checked against retention too");
assert!(
error.to_string().contains("does not declare it preserves"),
"{error}"
);
}
#[tokio::test]
async fn ignored_params_surface_undeclared_knobs() {
let root = TempDir::new().expect("tempdir");
let text = root.path().join("x.txt");
fs::write(&text, b"payload").unwrap();
let converter = converter_with(vec![Scripted::new(
"scripted",
vec![("txt", "copyfmt", "copy")],
)]);
let mut params = std::collections::BTreeMap::new();
params.insert("quality".to_owned(), "80".to_owned());
params.insert("bogus".to_owned(), "1".to_owned());
let report = converter
.convert(
std::slice::from_ref(&text),
"copyfmt",
&ConversionOptions {
from: Some("txt".into()),
params,
..options()
},
)
.await
.expect("conversion succeeds with unknown params present");
assert_eq!(report.ignored_params, vec!["bogus".to_owned()]);
let identity = converter
.convert(
std::slice::from_ref(&text),
"txt",
&ConversionOptions {
params: std::collections::BTreeMap::from([("quality".to_owned(), "50".to_owned())]),
..options()
},
)
.await
.expect("identity copy accepts any params");
assert_eq!(identity.ignored_params, vec!["quality".to_owned()]);
}
struct Keeper {
retained: &'static [&'static str],
}
impl Adapter for Keeper {
fn name(&self) -> &str {
"keeper"
}
fn formats(&self) -> Vec<Format> {
vec![
Format::new("keeper-src", "Source", MediaKind::Binary).with_extensions(&["ksrc"]),
Format::new("keeper-dst", "Target", MediaKind::Binary),
]
}
fn conversions(&self) -> Vec<Conversion> {
vec![
Conversion::new(
"keeper-src",
"keeper-dst",
"keeper",
"copy",
ConversionKind::Lossless,
1,
)
.with_retained(self.retained),
]
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
let request = request.clone();
let input = request
.inputs
.first()
.ok_or_else(|| Error::Invalid("no input".into()))?;
let path = request.output_dir.join("kept.bin");
fs::copy(&input.path, &path)?;
Ok(vec![Artifact::new(path, request.to.clone())])
})
}
}
#[cfg(feature = "media")]
#[test]
fn probe_reports_decodable_formats_for_real_and_fake_files() {
let root = TempDir::new().expect("tempdir");
let converter = Converter::new();
let real = root.path().join("real.png");
image::DynamicImage::new_rgba8(1, 1)
.save(&real)
.expect("write png");
let report = converter.probe(&real).expect("probe real png");
assert_eq!(report.identification.format, "png");
assert!(
report.decodable_as.iter().any(|id| id == "png"),
"{:?}",
report.decodable_as
);
let liar = root.path().join("liar.png");
fs::write(&liar, b"RIFF junk but claimed as png").unwrap();
let report = converter.probe(&liar).expect("probe liar");
assert_eq!(report.identification.format, "png");
assert!(
!report.decodable_as.contains(&"png".to_owned()),
"garbage must not decode as png: {:?}",
report.decodable_as
);
}
#[cfg(feature = "media")]
#[test]
fn capabilities_classify_planned_policy_blocked_and_no_route() {
let converter = converter_with(vec![Arc::new(Keeper { retained: &[] })]);
let reports = converter
.capabilities("mp3", &["png".into(), "keeper-dst".into()])
.expect("capabilities");
let blocked = &reports[0];
assert_eq!(blocked.format, "png");
assert!(
matches!(blocked.reason, convert_rs::CapabilityReason::PolicyBlocked),
"{:?}",
blocked.reason
);
let missing = &reports[1];
assert_eq!(missing.format, "keeper-dst");
assert!(matches!(
missing.reason,
convert_rs::CapabilityReason::NoRoute
));
let planned = converter
.capabilities("txt", &["png".into()])
.expect("txt to png plans fine");
assert!(
matches!(
planned[0].reason,
convert_rs::CapabilityReason::Planned { .. }
),
"{:?}",
planned[0].reason
);
assert!(matches!(
converter.capabilities("txt", &["bogus-target".into()]),
Err(Error::Invalid(_))
));
assert!(matches!(
converter.capabilities("bogus-source", &["png".into()]),
Err(Error::Invalid(_))
));
}
#[cfg(feature = "media")]
#[test]
fn capabilities_report_policy_blocked_for_creative_only_routes() {
let creative = Converter::new().with_policy(Policy {
allow_creative: true,
..Policy::default()
});
let reports = creative
.capabilities("mp3", &["png".into()])
.expect("capabilities");
assert!(matches!(
reports[0].reason,
convert_rs::CapabilityReason::Planned { .. }
));
}
struct Prober {
observed: Option<ContentProfile>,
}
impl Prober {
fn new(observed: Option<ContentProfile>) -> Arc<dyn Adapter> {
Arc::new(Self { observed })
}
}
impl Adapter for Prober {
fn name(&self) -> &str {
"prober"
}
fn formats(&self) -> Vec<Format> {
vec![
Format::new("probe-in", "Probe in", MediaKind::Binary).with_extensions(&["probe-in"]),
Format::new("probe-out", "Probe out", MediaKind::Binary)
.with_extensions(&["probe-out"]),
]
}
fn conversions(&self) -> Vec<Conversion> {
vec![
Conversion::new(
"probe-in",
"probe-out",
self.name(),
"probe-copy",
ConversionKind::Lossless,
1,
)
.requiring(&[ContentKind::new(MediaKind::Audio)]),
]
}
fn inspect<'a>(
&'a self,
_path: &'a std::path::Path,
_format: &'a str,
_limits: &'a Limits,
) -> convert_rs::InspectFuture<'a> {
let observed = self.observed.clone();
Box::pin(async move { observed.map(Ok) })
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
let mut artifacts = Vec::new();
for (index, input) in request.inputs.iter().enumerate() {
let path = request
.output_dir
.join(format!("probed-{index}.{}", request.to));
fs::copy(&input.path, &path)?;
artifacts.push(Artifact::new(path, request.to.clone()));
}
Ok(artifacts)
})
}
}
fn audio_profile(format: &str) -> ContentProfile {
ContentProfile::new(format).with_stream(ContentKind::new(MediaKind::Audio))
}
fn video_profile(format: &str) -> ContentProfile {
ContentProfile::new(format).with_stream(ContentKind::new(MediaKind::Video))
}
async fn probe_input(dir: &TempDir) -> std::path::PathBuf {
let path = dir.path().join("input.probe-in");
fs::write(&path, b"probe payload bytes").expect("write input");
path
}
#[tokio::test]
async fn inspection_off_declines_content_gated_edge() {
let dir = TempDir::new().expect("tempdir");
let input = probe_input(&dir).await;
let converter = converter_with(vec![Prober::new(Some(audio_profile("probe-in")))]);
let options = options();
let result = converter
.convert(std::slice::from_ref(&input), "probe-out", &options)
.await;
assert!(
matches!(result, Err(Error::Plan(_))),
"no observed profile means no route: {result:?}"
);
}
#[tokio::test]
async fn inspection_on_accepts_content_gated_edge() {
let dir = TempDir::new().expect("tempdir");
let input = probe_input(&dir).await;
let converter = converter_with(vec![Prober::new(Some(audio_profile("probe-in")))]);
let options = ConversionOptions {
inspect_content: true,
..options()
};
let report = converter
.convert(std::slice::from_ref(&input), "probe-out", &options)
.await
.expect("observed audio unlocks the edge");
assert_eq!(report.artifacts.len(), 1);
assert_eq!(report.artifacts[0].format, "probe-out");
}
#[tokio::test]
async fn observed_profile_without_required_content_still_declines() {
let dir = TempDir::new().expect("tempdir");
let input = probe_input(&dir).await;
let converter = converter_with(vec![Prober::new(Some(video_profile("probe-in")))]);
let options = ConversionOptions {
inspect_content: true,
..options()
};
let result = converter
.convert(std::slice::from_ref(&input), "probe-out", &options)
.await;
assert!(
matches!(result, Err(Error::Plan(_))),
"a video-only profile cannot satisfy an audio requirement: {result:?}"
);
}
#[tokio::test]
async fn policy_inspect_content_flag_replaces_the_per_call_option() {
let dir = TempDir::new().expect("tempdir");
let input = probe_input(&dir).await;
let converter =
converter_with(vec![Prober::new(Some(audio_profile("probe-in")))]).with_policy(Policy {
inspect_content: true,
..Policy::default()
});
let report = converter
.convert(std::slice::from_ref(&input), "probe-out", &options())
.await
.expect("policy-level inspection routes the edge");
assert_eq!(report.artifacts[0].format, "probe-out");
}
#[tokio::test]
async fn profile_reports_observed_and_declined_sources() {
let dir = TempDir::new().expect("tempdir");
let input = probe_input(&dir).await;
let observed = converter_with(vec![Prober::new(Some(audio_profile("probe-in")))]);
let report = observed.profile(&input).await.expect("profile");
assert_eq!(report.identification.format, "probe-in");
assert!(matches!(report.source, ProfileSource::Observed));
let profile = report.profile.expect("observed profile");
assert!(profile.declares(&ContentKind::new(MediaKind::Audio)));
let silent = converter_with(vec![Prober::new(None)]);
let report = silent.profile(&input).await.expect("profile");
assert!(matches!(report.source, ProfileSource::NoOpinion));
assert!(
report.profile.is_none(),
"declining keeps the profile unset"
);
}
#[tokio::test]
async fn forced_plan_conflicts_with_inspection_request() {
let dir = TempDir::new().expect("tempdir");
let input = probe_input(&dir).await;
let converter = converter_with(vec![Prober::new(Some(audio_profile("probe-in")))]);
let forced = Plan::new(vec![Conversion::new(
"probe-in",
"probe-out",
"prober",
"probe-copy",
ConversionKind::Lossless,
1,
)]);
let options = ConversionOptions {
inspect_content: true,
forced_plan: Some(forced),
..options()
};
let result = converter
.convert(std::slice::from_ref(&input), "probe-out", &options)
.await;
assert!(
matches!(result, Err(Error::Invalid(_))),
"a forced plan cannot also demand inspection: {result:?}"
);
}