GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! Tests of the Media Browser (`media_browser`) against a fake filesystem: listing, file-type
//! filter, navigation history, Favorites, recent directories, import and Open in Source Monitor.

use std::collections::BTreeMap;
use std::sync::{Arc, Mutex};

use serde_json::{Value, json};

use crate::media_browser::{self, DirEntry, Volume, VolumeKind};
use crate::{Services, Session};

/// An in-memory filesystem: directories and files (with bytes).
#[derive(Default)]
struct FakeFs {
    dirs: Vec<String>,
    /// Folders that are listed in their parent but cannot be listed themselves.
    denied: Vec<String>,
    files: Mutex<BTreeMap<String, Vec<u8>>>,
}

impl FakeFs {
    fn new() -> Self {
        let wav = filmcraft_media::wav::write_wav16(&[0.0; 4800], 2, 48_000);
        let mut files = BTreeMap::new();
        for f in ["/home/me/Movies/b-roll.wav", "/home/me/Movies/A-interview.wav", "/home/me/Movies/notes.txt", "/home/me/Movies/.hidden.wav"] {
            files.insert(f.to_string(), wav.clone());
        }
        for f in [
            "/home/me/Movies/shot_0001.png",
            "/home/me/Movies/shot_0002.png",
            "/home/me/Movies/edit.edl",
            "/home/me/Movies/subs.srt",
            "/home/me/Movies/clip.mov",
            "/home/me/Movies/CLIP.MOV",
        ] {
            files.insert(f.to_string(), vec![0; 16]);
        }
        files.insert("/Volumes/Card/DCIM/take1.wav".into(), wav);
        FakeFs {
            dirs: ["/", "/home", "/home/me", "/home/me/Movies", "/home/me/Movies/Selects", "/Volumes", "/Volumes/Card", "/Volumes/Card/DCIM"]
                .iter()
                .map(|d| d.to_string())
                .collect(),
            denied: Vec::new(),
            files: Mutex::new(files),
        }
    }
}

impl Services for FakeFs {
    fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>> {
        self.files.lock().unwrap().get(path).cloned().ok_or_else(|| std::io::Error::new(std::io::ErrorKind::NotFound, path.to_string()))
    }
    fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
        self.files.lock().unwrap().insert(path.into(), data.to_vec());
        Ok(())
    }
    fn file_size(&self, path: &str) -> std::io::Result<u64> {
        self.read_file(path).map(|b| b.len() as u64)
    }
    fn list_entries(&self, dir: &str) -> Option<std::io::Result<Vec<DirEntry>>> {
        if !self.dirs.iter().any(|d| d == dir) {
            return Some(Err(std::io::Error::new(std::io::ErrorKind::NotFound, dir.to_string())));
        }
        if self.denied.iter().any(|d| d == dir) {
            return Some(Err(std::io::Error::new(std::io::ErrorKind::PermissionDenied, "permission denied")));
        }
        let prefix = if dir == "/" { "/".to_string() } else { format!("{dir}/") };
        let direct = |p: &str| p.strip_prefix(&prefix).filter(|r| !r.is_empty() && !r.contains('/')).map(str::to_string);
        let mut v: Vec<DirEntry> =
            self.dirs.iter().filter_map(|d| direct(d)).map(|name| DirEntry { name, is_dir: true, size: None, modified: Some(0) }).collect();
        for (p, b) in self.files.lock().unwrap().iter() {
            if let Some(name) = direct(p) {
                v.push(DirEntry { name, is_dir: false, size: Some(b.len() as u64), modified: Some(1_700_000_000) });
            }
        }
        Some(Ok(v))
    }
    fn list_dir(&self, dir: &str) -> Option<std::io::Result<Vec<String>>> {
        self.list_entries(dir).map(|r| r.map(|v| v.into_iter().map(|e| e.name).collect()))
    }
    fn volumes(&self) -> Vec<Volume> {
        vec![
            Volume { name: "Macintosh HD".into(), path: "/".into(), kind: VolumeKind::Local },
            Volume { name: "Card".into(), path: "/Volumes/Card".into(), kind: VolumeKind::Local },
            Volume { name: "Studio".into(), path: "/Network/Studio".into(), kind: VolumeKind::Network },
        ]
    }
    fn home_dir(&self) -> Option<String> {
        Some("/home/me".into())
    }
}

fn session() -> Session {
    Session::new(Arc::new(FakeFs::new()))
}

fn names(v: &Value) -> Vec<String> {
    v["entries"].as_array().unwrap().iter().map(|e| e["name"].as_str().unwrap().to_string()).collect()
}

#[test]
fn listing_puts_folders_first_and_hides_unsupported_files() {
    let mut s = session();
    // starts in the home directory
    let l = s.execute("mediaBrowser.list", json!({})).unwrap();
    assert_eq!(l["dir"], "/home/me");
    assert_eq!(names(&l), ["Movies"]);
    let l = s.execute("mediaBrowser.list", json!({"path": "/home/me/Movies"})).unwrap();
    assert_eq!(names(&l), ["Selects", "A-interview.wav", "b-roll.wav", "CLIP.MOV", "clip.mov", "edit.edl", "shot_0001.png", "shot_0002.png", "subs.srt"]);
    let e = &l["entries"][0];
    assert_eq!((e["isDir"].as_bool(), e["kind"].as_str()), (Some(true), Some("folder")));
    let shot = l["entries"].as_array().unwrap().iter().find(|e| e["name"] == "shot_0001.png").unwrap();
    assert_eq!(shot["numbered"], true);
    assert_eq!(shot["path"], "/home/me/Movies/shot_0001.png");
    assert!(s.execute("mediaBrowser.list", json!({"path": "/nope"})).is_err());
}

#[test]
fn file_type_filter() {
    let mut s = session();
    let l = s.execute("mediaBrowser.list", json!({"path": "/home/me/Movies", "fileTypes": "audio"})).unwrap();
    assert_eq!(names(&l), ["Selects", "A-interview.wav", "b-roll.wav"], "folders always show");
    let l = s.execute("mediaBrowser.list", json!({"path": "/home/me/Movies", "fileTypes": "image"})).unwrap();
    assert_eq!(names(&l), ["Selects", "shot_0001.png", "shot_0002.png"]);
    let l = s.execute("mediaBrowser.list", json!({"path": "/home/me/Movies", "fileTypes": "mov"})).unwrap();
    assert_eq!(names(&l), ["Selects", "CLIP.MOV", "clip.mov"]);
    // the setting persists and applies by default
    s.execute("mediaBrowser.settings", json!({"fileTypes": "project"})).unwrap();
    let l = s.execute("mediaBrowser.list", json!({"path": "/home/me/Movies"})).unwrap();
    assert_eq!(names(&l), ["Selects", "edit.edl"]);
    assert!(s.execute("mediaBrowser.settings", json!({"fileTypes": "docx"})).is_err());
    assert!(s.execute("mediaBrowser.settings", json!({"view": "cards"})).is_err());
    s.execute("mediaBrowser.settings", json!({"view": "thumbnails", "columns": ["size", "Frame Rate"]})).unwrap();
    assert_eq!(s.prefs.media_browser.view, "thumbnails");
    assert_eq!(s.prefs.media_browser.columns, ["Name", "Size", "Frame Rate"]);
}

#[test]
fn column_widths_persist_clamped() {
    let mut s = session();
    s.execute("mediaBrowser.settings", json!({"columnWidths": {"name": 300, "Size": 5}})).unwrap();
    s.execute("mediaBrowser.settings", json!({"columnWidths": {"Frame Rate": 90}})).unwrap();
    let w = &s.prefs.media_browser.column_widths;
    assert_eq!((w.get("Name"), w.get("Size"), w.get("Frame Rate")), (Some(&300.0), Some(&30.0), Some(&90.0)));
    assert!(s.execute("mediaBrowser.settings", json!({"columnWidths": {"Colour": 100}})).is_err());
    assert!(s.execute("mediaBrowser.settings", json!({"columnWidths": {"Name": "wide"}})).is_err());
    assert_eq!(s.prefs.media_browser.column_widths.len(), 3);
}

#[test]
fn navigation_back_forward_up_and_recent() {
    let mut s = session();
    s.execute("mediaBrowser.navigate", json!({"path": "/home/me/Movies"})).unwrap();
    s.execute("mediaBrowser.navigate", json!({"path": "/home/me/Movies/Selects"})).unwrap();
    let r = s.execute("mediaBrowser.navigate", json!({"up": true})).unwrap();
    assert_eq!(r["dir"], "/home/me/Movies");
    let r = s.execute("mediaBrowser.navigate", json!({"back": true})).unwrap();
    assert_eq!(r["dir"], "/home/me/Movies/Selects");
    assert_eq!(r["canForward"], true);
    let r = s.execute("mediaBrowser.navigate", json!({"back": true})).unwrap();
    assert_eq!(r["dir"], "/home/me/Movies");
    let r = s.execute("mediaBrowser.navigate", json!({"forward": true})).unwrap();
    assert_eq!(r["dir"], "/home/me/Movies/Selects");
    // a new location clears forward history
    s.execute("mediaBrowser.navigate", json!({"path": "/Volumes/Card"})).unwrap();
    assert!(s.execute("mediaBrowser.navigate", json!({"forward": true})).is_err());
    // a directory that can't be listed leaves the browser where it was
    assert!(s.execute("mediaBrowser.navigate", json!({"path": "/missing"})).is_err());
    assert_eq!(media_browser::current_dir(&s), "/Volumes/Card");
    // recent: newest first, no duplicates; the last directory is remembered
    assert_eq!(s.prefs.media_browser.recent[..3], ["/Volumes/Card", "/home/me/Movies/Selects", "/home/me/Movies"]);
    assert_eq!(s.prefs.media_browser.last_dir, "/Volumes/Card");
    let roots = s.execute("mediaBrowser.roots", json!({})).unwrap();
    assert_eq!(roots["localDrives"].as_array().unwrap().len(), 2);
    assert_eq!(roots["network"][0]["name"], "Studio");
    assert_eq!(roots["recent"][0]["name"], "Card");
    s.execute("mediaBrowser.clearRecent", json!({})).unwrap();
    assert!(s.prefs.media_browser.recent.is_empty());
    // up at the root fails
    s.execute("mediaBrowser.navigate", json!({"path": "/"})).unwrap();
    assert!(s.execute("mediaBrowser.navigate", json!({"up": true})).is_err());
}

#[test]
fn favorites_add_and_remove() {
    let mut s = session();
    s.execute("mediaBrowser.navigate", json!({"path": "/home/me/Movies"})).unwrap();
    s.execute("mediaBrowser.favorite", json!({})).unwrap();
    s.execute("mediaBrowser.favorite", json!({"path": "/Volumes/Card/DCIM"})).unwrap();
    s.execute("mediaBrowser.favorite", json!({})).unwrap();
    assert_eq!(s.prefs.media_browser.favorites, ["/home/me/Movies", "/Volumes/Card/DCIM"], "no duplicates");
    let r = s.execute("mediaBrowser.list", json!({})).unwrap();
    assert_eq!(r["favorite"], true);
    let roots = s.execute("mediaBrowser.roots", json!({})).unwrap();
    assert_eq!(roots["favorites"][1]["name"], "DCIM");
    s.execute("mediaBrowser.favorite", json!({"remove": true})).unwrap();
    assert_eq!(s.prefs.media_browser.favorites, ["/Volumes/Card/DCIM"]);
    assert!(s.execute("mediaBrowser.favorite", json!({"remove": true})).is_err());
}

#[test]
fn import_the_selection_and_open_in_source() {
    let mut s = session();
    s.execute("mediaBrowser.navigate", json!({"path": "/home/me/Movies"})).unwrap();
    assert!(s.execute("mediaBrowser.import", json!({})).is_err(), "nothing selected");
    s.execute("mediaBrowser.select", json!({"paths": ["/home/me/Movies/b-roll.wav", "/home/me/Movies/A-interview.wav"]})).unwrap();
    let r = s.execute("mediaBrowser.import", json!({})).unwrap();
    assert_eq!(r["items"].as_array().unwrap().len(), 2, "{r}");
    assert_eq!(s.project.items.len(), 2);
    // undoable like any import
    s.execute("edit.undo", json!({})).unwrap();
    s.execute("edit.undo", json!({})).unwrap();
    assert!(s.project.items.is_empty());
    // File ▸ Import from Media Browser uses the selection too
    let r = s.execute("file.importFromMediaBrowser", json!({})).unwrap();
    assert_eq!(r["items"].as_array().unwrap().len(), 2);
    // Open In Source Monitor reuses the imported item
    let n = s.project.items.len();
    let r = s.execute("mediaBrowser.openInSource", json!({"path": "/home/me/Movies/b-roll.wav"})).unwrap();
    assert_eq!(s.project.items.len(), n);
    assert_eq!(s.state.source_item.map(|i| i.0), r["item"].as_u64());
    // ... and imports a file not in the project yet
    s.execute("mediaBrowser.openInSource", json!({"path": "/Volumes/Card/DCIM/take1.wav"})).unwrap();
    assert_eq!(s.project.items.len(), n + 1);
    // importing a folder imports its media files
    let mut s = session();
    let r = s.execute("mediaBrowser.import", json!({"paths": ["/Volumes/Card/DCIM"]})).unwrap();
    assert_eq!(r["items"].as_array().unwrap().len(), 1);
}

/// Importing a folder keeps its structure (#411): the folder becomes a bin named after it, each
/// sub-folder with media a bin inside that, and every file lands in its folder's bin.
#[test]
fn importing_a_folder_mirrors_its_sub_folders_as_bins() {
    let mut fs = FakeFs::new();
    let wav = filmcraft_media::wav::write_wav16(&[0.0; 4800], 2, 48_000);
    fs.dirs.extend(["/Shoot", "/Shoot/Day 1", "/Shoot/Day 1/Cam A", "/Shoot/Empty"].map(String::from));
    for f in ["/Shoot/slate.wav", "/Shoot/Day 1/room.wav", "/Shoot/Day 1/Cam A/take1.wav", "/Shoot/Day 1/Cam A/take2.wav"] {
        fs.files.get_mut().unwrap().insert(f.into(), wav.clone());
    }
    let mut s = Session::new(Arc::new(fs));
    let r = s.execute("mediaBrowser.import", json!({"paths": ["/Shoot"]})).unwrap();
    assert_eq!(r["items"].as_array().unwrap().len(), 4, "{r}");
    assert_eq!(r["bins"].as_array().unwrap().len(), 3, "{r}");
    let tree = |b: &filmcraft_project::Bin| -> Vec<String> {
        b.children
            .iter()
            .map(|c| match c {
                filmcraft_project::BinEntry::Bin(b) => format!("bin {}", b.name),
                filmcraft_project::BinEntry::Item(i) => s.project.item(*i).unwrap().name.clone(),
            })
            .collect()
    };
    let sub = |b: &filmcraft_project::Bin, name: &str| -> filmcraft_project::Bin {
        b.children
            .iter()
            .find_map(|c| match c {
                filmcraft_project::BinEntry::Bin(b) if b.name == name => Some(b.clone()),
                _ => None,
            })
            .unwrap()
    };
    assert_eq!(tree(&s.project.root), ["bin Shoot"]);
    let shoot = sub(&s.project.root, "Shoot");
    // a folder without media gets no bin
    assert_eq!(tree(&shoot), ["slate.wav", "bin Day 1"]);
    let day = sub(&shoot, "Day 1");
    assert_eq!(tree(&day), ["room.wav", "bin Cam A"]);
    assert_eq!(tree(&sub(&day, "Cam A")), ["take1.wav", "take2.wav"]);
}

#[test]
fn import_with_ingest_settings() {
    let mut s = session();
    s.execute("project.ingestSettings", json!({"enabled": true, "action": "copy", "destination": "/home/me/Ingest"})).unwrap();
    let r = s.execute("mediaBrowser.import", json!({"paths": ["/home/me/Movies/b-roll.wav"]})).unwrap();
    // the copy itself needs a real disk: the fake one makes it fail, which the result reports
    let ran = !r["ingest"].is_null() || r["errors"].as_array().is_some_and(|e| e.iter().any(|x| x.as_str().unwrap_or("").starts_with("ingest")));
    assert!(ran, "ingest ran: {r}");
    assert_eq!(r["items"].as_array().unwrap().len(), 1);
}

#[test]
fn probe_and_columns() {
    let mut s = session();
    let r = s.execute("mediaBrowser.probe", json!({"path": "/home/me/Movies/b-roll.wav"})).unwrap();
    assert_eq!(r["media"], true);
    let l = media_browser::list(&*s.services, "/home/me/Movies", "all").unwrap();
    let e = l.iter().find(|e| e.name == "b-roll.wav").unwrap();
    let info = media_browser::probe(&mut s, &e.path);
    assert_eq!(media_browser::column_text(e, "Audio Info", info.as_ref()), "48000 Hz - 2 ch");
    assert!(media_browser::column_text(e, "Media Duration", info.as_ref()).starts_with("00:00:00"));
    assert_eq!(media_browser::column_text(e, "Media Type", None), "Audio");
    assert_eq!(media_browser::column_text(e, "Date Modified", None), "2023-11-14 22:13");
    // not media: cached as such
    assert!(media_browser::probe(&mut s, "/home/me/Movies/edit.edl").is_none());
}

#[test]
fn path_helpers() {
    assert_eq!(media_browser::join("/a", "b"), "/a/b");
    assert_eq!(media_browser::join("/", "b"), "/b");
    assert_eq!(media_browser::join("C:\\Media", "b.mov"), "C:\\Media\\b.mov");
    assert_eq!(media_browser::parent("/a/b"), Some("/a".into()));
    assert_eq!(media_browser::parent("/a"), Some("/".into()));
    assert_eq!(media_browser::parent("/"), None);
    assert_eq!(media_browser::parent("C:\\Media"), Some("C:\\".into()));
    assert_eq!(media_browser::base_name("/home/me/Movies/"), "Movies");
}

/// #157: browsing a folder read every file no streaming reader takes (an AVI, a WAV) whole into
/// memory, just to show its properties or to find out it isn't supported. Large ones are now
/// refused after the head; small ones still show their properties; MP4 is read through its index.
#[cfg(any(unix, windows))]
#[test]
fn probing_large_unstreamable_files_does_not_read_them_whole() {
    let dir = crate::media_test_util::tmp_dir("browser-probe-large");
    // a 100 MB "AVI" (sparse: nothing is written past the header)
    let avi = dir.join("camera.avi");
    let mut head = vec![0u8; 64];
    head[..4].copy_from_slice(b"RIFF");
    head[8..12].copy_from_slice(b"AVI ");
    std::fs::write(&avi, &head).unwrap();
    std::fs::OpenOptions::new().write(true).open(&avi).unwrap().set_len(crate::media_pool::PROBE_WHOLE_FILE_MAX + 36 * 1024 * 1024).unwrap();
    let wav = dir.join("voice.wav");
    std::fs::write(&wav, filmcraft_media::wav::write_wav16(&[0.1; 9_600], 2, 48_000)).unwrap();
    let mov = dir.join("clip.mov");
    crate::media_test_util::make_movie(&mov, filmcraft_media::DemoScene::OceanSunset, 64, 36, 24);
    let mut s = Session::default();
    assert!(media_browser::probe(&mut s, &avi.to_string_lossy()).is_none());
    assert_eq!(media_browser::probe(&mut s, &wav.to_string_lossy()).unwrap().audio().unwrap().channels, 2);
    assert!(media_browser::probe(&mut s, &mov.to_string_lossy()).unwrap().video.is_some());
    // importing is unchanged: it still opens files through the full path
    let r = s.execute("file.import", json!({"paths": [wav.to_string_lossy()]})).unwrap();
    assert_eq!(r["items"].as_array().unwrap().len(), 1);
    let _ = std::fs::remove_dir_all(&dir);
}

/// #1292: an Avid Log Exchange file is something FilmCraft writes (File ▸ Export), not a project
/// it can import, so the browser doesn't list it with the project files.
#[test]
fn ale_logs_are_not_offered_for_import() {
    assert_eq!(media_browser::kind_of("clips.ale"), None);
    assert!(!media_browser::extensions().contains(&"ale"));
    assert_eq!(media_browser::kind_of("cut.edl"), Some("project"));
}

/// The background probe returns `None` until its thread has the result, then the same properties
/// as the blocking probe; a path that isn't media is answered at once.
#[cfg(any(unix, windows))]
#[test]
fn probe_background_returns_the_blocking_probe_result() {
    let dir = crate::media_test_util::tmp_dir("browser-probe-background");
    let wav = dir.join("voice.wav");
    std::fs::write(&wav, filmcraft_media::wav::write_wav16(&[0.1; 9_600], 2, 48_000)).unwrap();
    let path = wav.to_string_lossy().to_string();
    let mut s = Session::default();
    let mut got = None;
    for _ in 0..500 {
        got = media_browser::probe_background(&mut s, &path);
        if got.is_some() {
            break;
        }
        std::thread::sleep(std::time::Duration::from_millis(10));
    }
    let background = got.expect("background probe finished").expect("wav has properties");
    let mut fresh = Session::default();
    let blocking = media_browser::probe(&mut fresh, &path).unwrap();
    assert_eq!(background.duration, blocking.duration);
    assert_eq!(background.audio().map(|a| a.sample_rate), blocking.audio().map(|a| a.sample_rate));
    let notes = dir.join("notes.txt");
    assert_eq!(media_browser::probe_background(&mut s, &notes.to_string_lossy()), Some(None));
    let _ = std::fs::remove_dir_all(&dir);
}

/// AAF and OMF documents import through `file.import` like EDL, FCP7 XML, FCPXML and OTIO, so the
/// browser lists them as projects too, including the `.omfi` spelling the importer accepts.
#[test]
fn every_interchange_document_the_importer_reads_is_listed() {
    for ext in crate::interchange::EXTENSIONS {
        let name = format!("cut.{ext}");
        assert_eq!(media_browser::kind_of(&name), Some("project"), "{name}");
        assert_eq!(media_browser::kind_of(&name.to_ascii_uppercase()), Some("project"), "{name}");
        assert!(media_browser::extensions().contains(&ext), "{ext}");
    }
    let mut s = session();
    s.services.write_file("/home/me/Movies/cut.aaf", &[0; 16]).unwrap();
    s.services.write_file("/home/me/Movies/mix.omf", &[0; 16]).unwrap();
    let l = s.execute("mediaBrowser.list", json!({"path": "/home/me/Movies", "fileTypes": "project"})).unwrap();
    assert_eq!(names(&l), ["Selects", "cut.aaf", "edit.edl", "mix.omf"]);
    let l = s.execute("mediaBrowser.list", json!({"path": "/home/me/Movies", "fileTypes": "aaf"})).unwrap();
    assert_eq!(names(&l), ["Selects", "cut.aaf"]);
}

/// Files dropped together with a folder that holds no media import, and the folder is reported
/// rather than silently skipped (#2632).
#[test]
fn importing_files_with_an_empty_folder_reports_the_folder() {
    let mut fs = FakeFs::new();
    let wav = filmcraft_media::wav::write_wav16(&[0.0; 4800], 2, 48_000);
    fs.dirs.extend(["/Shoot", "/Shoot/Empty"].map(String::from));
    fs.files.get_mut().unwrap().insert("/Shoot/slate.wav".into(), wav);
    let mut s = Session::new(Arc::new(fs));
    let r = s.execute("mediaBrowser.import", json!({"paths": ["/Shoot/slate.wav", "/Shoot/Empty"], "imageSequence": false})).unwrap();
    assert_eq!(r["items"].as_array().unwrap().len(), 1, "{r}");
    let errors = r["errors"].as_array().unwrap();
    assert!(errors.iter().any(|e| e.as_str().unwrap().contains("/Shoot/Empty: no media files")), "{r}");
}

/// A dropped folder whose sub-folder cannot be listed imports what it can and reports the
/// sub-folder, rather than silently leaving its media out (#2632).
#[test]
fn importing_a_folder_reports_a_sub_folder_it_cannot_list() {
    let mut fs = FakeFs::new();
    let wav = filmcraft_media::wav::write_wav16(&[0.0; 4800], 2, 48_000);
    fs.dirs.extend(["/Shoot", "/Shoot/Locked"].map(String::from));
    fs.denied.push("/Shoot/Locked".into());
    fs.files.get_mut().unwrap().insert("/Shoot/slate.wav".into(), wav);
    let mut s = Session::new(Arc::new(fs));
    let r = s.execute("mediaBrowser.import", json!({"paths": ["/Shoot"], "imageSequence": false})).unwrap();
    assert_eq!(r["items"].as_array().unwrap().len(), 1, "{r}");
    let errors = r["errors"].as_array().unwrap();
    assert!(errors.iter().any(|e| e.as_str().unwrap().starts_with("/Shoot/Locked: ")), "{r}");
}

/// When none of the dropped files import, the error still names the folders without media.
#[test]
fn a_failed_file_import_still_reports_the_empty_folders() {
    let mut fs = FakeFs::new();
    fs.dirs.extend(["/Shoot", "/Shoot/Empty"].map(String::from));
    let mut s = Session::new(Arc::new(fs));
    let e = s.execute("mediaBrowser.import", json!({"paths": ["/Shoot/missing.wav", "/Shoot/Empty"], "imageSequence": false})).unwrap_err();
    assert!(e.to_string().contains("/Shoot/Empty: no media files"), "{e}");
}