f67d38b35cc5
panels_tests.rs
//! Tests of the panel commands (`panels`): Events log, Metadata edits with undo.
use std::sync::Arc;
use filmcraft_project::{ItemId, Label};
use serde_json::{Value, json};
use crate::Session;
use crate::panels::Level;
fn demo() -> Session {
let mut s = Session::default();
s.execute("file.openDemoProject", json!({})).unwrap();
s
}
fn first_media(s: &Session) -> ItemId {
s.project.items.values().filter(|i| i.as_media().is_some()).map(|i| i.id).min().expect("a media item")
}
fn field<'a>(v: &'a Value, name: &str) -> &'a Value {
v["fields"].as_array().unwrap().iter().find(|f| f["name"] == name).unwrap_or_else(|| panic!("no field {name}: {v}"))
}
#[test]
fn metadata_edits_are_undoable_and_saved_in_the_project() {
let mut s = demo();
let id = first_media(&s);
let name = s.project.item(id).unwrap().name.clone();
let g = s.execute("metadata.get", json!({"item": id.0})).unwrap();
assert_eq!(field(&g, "Name")["value"], json!(name));
assert_eq!(field(&g, "Media Start")["editable"], json!(false));
assert_eq!(field(&g, "Description")["value"], json!(""));
for f in ["Frame Rate", "Media End", "Media Duration", "Video Info", "Video Codec", "Color Space", "File Path", "Scene", "Shot", "Log Note", "Tape Name"] {
field(&g, f);
}
let undo0 = s.history.undo.len();
s.execute("metadata.set", json!({"item": id.0, "field": "Description", "value": "Wide establishing shot"})).unwrap();
assert_eq!(s.project.item(id).unwrap().metadata["Description"], "Wide establishing shot");
assert_eq!(s.history.undo.len(), undo0 + 1);
assert_eq!(s.history.undo.last().unwrap().0, "Edit Metadata");
// several fields in one step, including the name and the label
s.execute("metadata.set", json!({"item": id.0, "fields": {"Scene": "12", "Shot": "4B", "Name": "Hero Shot", "Label": "Mango"}})).unwrap();
assert_eq!(s.history.undo.len(), undo0 + 2);
let it = s.project.item(id).unwrap();
assert_eq!((it.name.as_str(), it.label, it.metadata["Scene"].as_str(), it.metadata["Shot"].as_str()), ("Hero Shot", Label::Mango, "12", "4B"));
// the same value again is not a new undo step
s.execute("metadata.set", json!({"item": id.0, "field": "Scene", "value": "12"})).unwrap();
assert_eq!(s.history.undo.len(), undo0 + 2);
// undo / redo
s.execute("edit.undo", json!({})).unwrap();
let it = s.project.item(id).unwrap();
assert_eq!((it.name.as_str(), it.metadata.get("Scene")), (name.as_str(), None));
assert_eq!(it.metadata["Description"], "Wide establishing shot");
s.execute("edit.redo", json!({})).unwrap();
assert_eq!(s.project.item(id).unwrap().name, "Hero Shot");
// an empty value removes the field
s.execute("metadata.set", json!({"item": id.0, "field": "Shot", "value": ""})).unwrap();
assert!(!s.project.item(id).unwrap().metadata.contains_key("Shot"));
// errors: read-only fields, bad labels, empty names; nothing changes
let n = s.history.undo.len();
for bad in [
json!({"field": "Media Start", "value": "01:00:00:00"}),
json!({"field": "Label", "value": "Plaid"}),
json!({"field": "Name", "value": " "}),
json!({}),
] {
let mut p = bad.clone();
p["item"] = json!(id.0);
assert!(s.execute("metadata.set", p).is_err(), "{bad}");
}
assert_eq!(s.history.undo.len(), n);
// saved in the project file and read back
let bytes = filmcraft_format::encode(&s.project, false);
let back = filmcraft_format::decode(&bytes).unwrap().project;
assert_eq!(back.item(id).unwrap().metadata["Scene"], "12");
}
/// The Out Point is the last frame the marks keep, the frame a Source edit places last and the
/// Project panel's Video Out Point. It read one frame earlier.
#[test]
fn metadata_out_point_is_the_last_frame_kept() {
let mut s = demo();
let id = s.project.items.values().filter(|i| i.as_media().is_some() && i.has_video()).map(|i| i.id).min().expect("a video clip");
s.execute("source.open", json!({"item": id.0})).unwrap();
s.execute("markers.markIn", json!({"target": "source", "frame": 24})).unwrap();
s.execute("markers.markOut", json!({"target": "source", "frame": 71})).unwrap();
let g = s.execute("metadata.get", json!({"item": id.0})).unwrap();
let it = s.project.item(id).unwrap();
for (field_name, column) in [("In Point", "Video In Point"), ("Out Point", "Video Out Point")] {
assert_eq!(field(&g, field_name)["value"], json!(crate::project_panel::cell(&s.project, it, column).0), "{field_name}");
}
let (_, range) = crate::commands::source_range(&s).unwrap();
let rate = it.frame_rate();
assert_eq!((rate.frame_at(range.start), rate.frame_at(range.end())), (24, 72), "a Source edit places frames 24 to 71");
}
#[test]
fn metadata_targets_follow_the_selection() {
let mut s = demo();
let seq = s.active_sequence().unwrap().clone();
let clip = &seq.video_tracks[0].items[0];
// nothing selected in the Project panel: the timeline selection
s.state.project_selection.clear();
s.state.selection = vec![clip.id];
let g = s.execute("metadata.get", json!({})).unwrap();
assert_eq!(g["item"], json!(clip.item.0));
// a timeline clip by id
let g = s.execute("metadata.get", json!({"clip": clip.id.0})).unwrap();
assert_eq!(g["item"], json!(clip.item.0));
s.execute("metadata.set", json!({"clip": clip.id.0, "field": "Log Note", "value": "soft focus"})).unwrap();
assert_eq!(s.project.item(clip.item).unwrap().metadata["Log Note"], "soft focus");
// the Project panel selection wins
let other = first_media(&s);
s.state.project_selection = vec![other];
assert_eq!(s.execute("metadata.get", json!({})).unwrap()["item"], json!(other.0));
s.state.project_selection.clear();
s.state.selection.clear();
assert!(s.execute("metadata.get", json!({})).is_err());
}
#[test]
fn events_log_failed_commands_jobs_and_messages() {
let mut s = demo();
s.execute("events.clear", json!({})).unwrap();
assert!(s.execute("clip.rename", json!({})).is_err());
assert!(s.execute("clip.rename", json!({})).is_err());
let l = s.execute("events.list", json!({})).unwrap();
let e = &l["entries"].as_array().unwrap()[0];
assert_eq!((e["level"].as_str(), e["source"].as_str(), e["count"].as_u64()), (Some("error"), Some("clip.rename"), Some(2)));
assert!(e["message"].as_str().unwrap().contains("name"), "{e}");
// a disabled command is a warning
s.history.undo.clear();
assert!(s.execute("edit.undo", json!({})).is_err());
assert_eq!(s.log.entries.back().map(|e| (e.level, e.source.as_str())), Some((Level::Warning, "edit.undo")));
// messages are info
s.toast("Saved");
s.error_toast("autosave", "disk full");
let l = s.execute("events.list", json!({"level": "error"})).unwrap();
assert!(l["entries"].as_array().unwrap().iter().all(|e| e["level"] == "error"));
assert_eq!(l["counts"]["error"], json!(2));
assert_eq!(l["counts"]["info"], json!(1));
let last = l["entries"].as_array().unwrap().last().unwrap()["id"].as_u64().unwrap();
assert!(s.execute("events.list", json!({"since": last})).unwrap()["entries"].as_array().unwrap().is_empty());
// nested commands report only the outer failure; queries and successes add nothing
let before = s.log.entries.len();
s.execute("project.inspect", json!({})).unwrap();
assert_eq!(s.log.entries.len(), before);
s.execute("events.clear", json!({})).unwrap();
assert!(s.log.entries.is_empty());
}
#[test]
fn events_report_background_jobs() {
let mut s = demo();
s.execute("events.clear", json!({})).unwrap();
let job = |id, label: &str| crate::Job { id, label: label.into(), progress: Arc::new(Default::default()), result: Arc::new(std::sync::Mutex::new(None)) };
let (a, b, c) = (job(901, "Export a.mp4"), job(902, "Create Proxies"), job(903, "Scene Edit Detection"));
s.jobs.extend([a.clone(), b.clone(), c.clone()]);
s.poll_persistence();
assert_eq!(s.log.entries.iter().filter(|e| e.message.starts_with("Started:")).count(), 3);
*a.result.lock().unwrap() =
Some(Ok(filmcraft_export::Report { path: "a.mp4".into(), frames: 1, seconds: 0.1, bytes: 1, render_fps: 10.0, ..Default::default() }));
*b.result.lock().unwrap() = Some(Err("disk full".into()));
c.progress.cancel.store(true, std::sync::atomic::Ordering::Relaxed);
*c.result.lock().unwrap() = Some(Err("cancelled".into()));
let l = s.execute("events.list", json!({})).unwrap();
let msgs: Vec<(String, String)> =
l["entries"].as_array().unwrap().iter().map(|e| (e["level"].as_str().unwrap().into(), e["message"].as_str().unwrap().into())).collect();
assert!(msgs.contains(&("info".into(), "Finished: Export a.mp4".into())), "{msgs:?}");
assert!(msgs.contains(&("error".into(), "Failed: Create Proxies: disk full".into())), "{msgs:?}");
assert!(msgs.contains(&("warning".into(), "Cancelled: Scene Edit Detection".into())), "{msgs:?}");
// reported once
s.poll_persistence();
assert_eq!(s.log.entries.len(), 6);
}
/// #3952: a finished export's warnings (hardware encoding asked for, but the software encoder ran)
/// show in Events after its "Finished" line, once each, so the desktop app says so too.
#[test]
fn events_show_a_finished_exports_warnings() {
let fell_back = "hardware encoding declined (NVENC: two-pass VBR); the software H.264 encoder ran";
let other = "another thing the export reported";
for (name, warnings) in [("none", vec![]), ("fallback", vec![fell_back]), ("two", vec![fell_back, other])] {
let mut s = demo();
s.execute("events.clear", json!({})).unwrap();
let job = crate::Job { id: 911, label: "Export a.mp4".into(), progress: Arc::new(Default::default()), result: Arc::new(std::sync::Mutex::new(None)) };
s.jobs.push(job.clone());
let warnings: Vec<String> = warnings.into_iter().map(String::from).collect();
let report = filmcraft_export::Report { path: "a.mp4".into(), encoder: Some("software".into()), warnings: warnings.clone(), ..Default::default() };
*job.result.lock().unwrap() = Some(Ok(report));
let l = s.execute("events.list", json!({})).unwrap();
let msgs: Vec<(String, String)> = l["entries"]
.as_array()
.unwrap()
.iter()
.map(|e| (e["level"].as_str().unwrap().into(), e["message"].as_str().unwrap().into()))
.filter(|(_, m): &(String, String)| m.contains("Export a.mp4"))
.collect();
let mut want = vec![("info".to_string(), "Started: Export a.mp4".to_string()), ("info".into(), "Finished: Export a.mp4".into())];
want.extend(warnings.iter().map(|w| ("warning".to_string(), format!("Export a.mp4: {w}"))));
assert_eq!(msgs, want, "{name}");
// reported once
let n = s.log.entries.len();
s.poll_persistence();
assert_eq!(s.log.entries.len(), n, "{name}");
}
}
/// #620: project notes are saved in the project file; typing (one `merge` key) is one undo step.
#[test]
fn project_notes_are_saved_and_typing_is_one_undo_step() {
let mut s = demo();
assert_eq!(s.execute("project.notes", json!({})).unwrap()["text"], "");
let undo0 = s.history.undo.len();
for text in ["T", "To", "To do: fix the logo at 00:01:02:03"] {
s.execute("project.setNotes", json!({"text": text, "merge": "1"})).unwrap();
}
assert_eq!(s.history.undo.len(), undo0 + 1, "one typing session, one undo step");
assert_eq!(s.history.undo.last().unwrap().0, "Edit Project Notes");
// the same text again changes nothing and adds no step
let r = s.execute("project.setNotes", json!({"text": "To do: fix the logo at 00:01:02:03"})).unwrap();
assert_eq!(r["changed"], json!(false));
assert_eq!(s.history.undo.len(), undo0 + 1);
let loaded = filmcraft_format::decode(&filmcraft_format::encode(&s.project, false)).unwrap();
assert_eq!(loaded.project.notes, "To do: fix the logo at 00:01:02:03");
// an older file without notes still loads, with none
let mut doc: Value = serde_json::from_slice(&filmcraft_format::encode(&filmcraft_project::Project::new("old"), false)).unwrap();
doc["schema_version"] = json!(14);
assert_eq!(filmcraft_format::decode(&serde_json::to_vec(&doc).unwrap()).unwrap().project.notes, "");
s.execute("edit.undo", json!({})).unwrap();
assert_eq!(s.project.notes, "");
}
#[test]
fn project_notes_refuse_bad_input() {
let mut s = demo();
assert!(s.execute("project.setNotes", json!({})).is_err());
assert!(s.execute("project.setNotes", json!({"text": 5})).is_err());
let huge = "x".repeat(crate::panels::MAX_NOTES_BYTES + 1);
assert!(s.execute("project.setNotes", json!({"text": huge})).is_err());
assert_eq!(s.project.notes, "");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.