Skip to content

AI media harness for planning, generating, and editing locally

TypeScript
6.7 KB
Raw Blame
use super::*;

#[test]
fn long_shot_resolves_both_archives_inside_the_project_only() {
    let folder = project_folder();
    let root = folder.path().to_string_lossy();
    let destination = generated_latent_destination(&root, "anchor").unwrap();
    fs::write(&destination, b"latents").unwrap();
    let mut request = slopfab::GenerationRequest {
        latent_bridge: Some(slopfab::LatentBridgeRequest {
            left_relative_path: Some("latents/anchor.safetensors".into()), right_relative_path: Some("latents/anchor.safetensors".into()),
            ..Default::default()
        }), ..Default::default()
    };
    assert!(prepare_continuation_path(&mut request, None).is_err());
    prepare_continuation_path(&mut request, Some(&root)).unwrap();
    assert_eq!(request.bridge_left_path.as_ref(), Some(&destination));
    assert_eq!(request.bridge_right_path.as_ref(), Some(&destination));
    for invalid in ["../outside.safetensors", "C:/outside.safetensors", "latents/missing.safetensors", "latents"] {
        request.latent_bridge.as_mut().unwrap().right_relative_path = Some(invalid.into());
        assert!(prepare_continuation_path(&mut request, Some(&root)).is_err());
        assert!(request.bridge_right_path.is_none());
    }
}

#[test]
fn a_rendered_scene_lands_in_the_project_under_its_own_id() {
    let folder = project_folder();
    let (destination, relative) =
        generated_video_destination(&folder.path().to_string_lossy(), "job-initial-brief").unwrap();
    assert_eq!(relative, "media/generated/job-initial-brief.mp4");
    assert!(destination.ends_with("media/generated/job-initial-brief.mp4"));
    // The folder is made, so the write that follows has somewhere to go.
    assert!(destination.parent().unwrap().is_dir());
    // And it really is inside the project, not merely named as though it were.
    assert!(destination.starts_with(folder.path().canonicalize().unwrap()));
}

#[test]
fn context_latents_are_resolved_inside_the_project_and_not_accepted_as_host_paths() {
    let folder = project_folder();
    let root = folder.path().to_string_lossy();
    let destination = generated_latent_destination(&root, "context").unwrap();
    fs::write(&destination, b"archive").unwrap();
    let mut request: slopfab::GenerationRequest = serde_json::from_value(serde_json::json!({
        "jobId": "next", "prompt": "Continue", "frames": 119, "steps": 9, "seed": 1,
        "canvasWidth": 736, "canvasHeight": 416,
        "keystoneRelativePath": "latents/context.safetensors", "keystonePath": "C:/outside.safetensors"
    })).unwrap();
    assert!(request.keystone_path.is_none());
    assert!(prepare_continuation_path(&mut request, None).is_err());
    prepare_continuation_path(&mut request, Some(&root)).unwrap();
    assert_eq!(request.keystone_path.as_ref(), Some(&destination));
    for invalid in ["../outside.safetensors", "C:/outside.safetensors", "latents/missing.safetensors", "latents"] {
        request.keystone_relative_path = Some(invalid.into());
        assert!(prepare_continuation_path(&mut request, Some(&root)).is_err());
        assert!(request.keystone_path.is_none());
    }
}

#[test]
fn latent_archives_are_unique_and_confined_to_the_project() {
    let folder = project_folder();
    let root = folder.path().to_string_lossy();
    let destination = generated_latent_destination(&root, "work-one").unwrap();
    assert!(destination.ends_with("latents/work-one.safetensors"));
    fs::write(&destination, b"archive").unwrap();
    assert!(generated_latent_destination(&root, "work-one").is_err());
    assert!(generated_latent_destination(&root, "../escape").is_err());
    let mut request: slopfab::GenerationRequest = serde_json::from_value(serde_json::json!({
        "jobId": "next", "prompt": "Continue", "frames": 119, "steps": 4, "seed": 1,
        "canvasWidth": 736, "canvasHeight": 416,
        "continuationRelativePath": "latents/work-one.safetensors",
        "saveLatentsPath": "C:/outside.safetensors", "continuationPath": "C:/outside.safetensors",
    }))
    .unwrap();
    assert!(request.save_latents_path.is_none());
    assert!(request.continuation_path.is_none());
    assert!(prepare_continuation_path(&mut request, None).is_err());
    prepare_continuation_path(&mut request, Some(&root)).unwrap();
    assert_eq!(request.continuation_path, Some(destination));
    for invalid in [
        "../outside.safetensors",
        "C:/outside.safetensors",
        "latents/missing.safetensors",
    ] {
        request.continuation_relative_path = Some(invalid.into());
        assert!(prepare_continuation_path(&mut request, Some(&root)).is_err());
    }
    let mut config = created_fixture();
    config.generation_jobs[0].latent_relative_path = Some("latents/work-one.safetensors".into());
    assert!(validate_and_normalize_config(config.clone()).is_ok());
    config.generation_jobs[0].latent_relative_path = Some("../outside.safetensors".into());
    assert!(validate_and_normalize_config(config).is_err());
}

#[test]
fn purging_timeline_thumbnails_removes_only_the_named_scene() {
    let folder = project_folder();
    let first = folder.path().join("thumbnails/timeline/job-first");
    let second = folder.path().join("thumbnails/timeline/job-second");
    fs::create_dir_all(&first).unwrap();
    fs::create_dir_all(&second).unwrap();
    fs::write(first.join("00000000.jpg"), b"first").unwrap();
    fs::write(second.join("00000000.jpg"), b"second").unwrap();

    purge_timeline_thumbnails(
        folder.path().to_string_lossy().into_owned(),
        "job-first".into(),
    )
    .unwrap();

    assert!(!first.exists());
    assert!(second.join("00000000.jpg").is_file());
}

#[test]
fn a_scene_id_that_is_not_a_scene_id_is_refused_rather_than_scrubbed() {
    let folder = project_folder();
    let root = folder.path().to_string_lossy().into_owned();
    for hostile in [
        "../../etc/passwd",
        "..",
        ".",
        "job/../../escape",
        r"job\..\escape",
        "job:stream",
        "job.mp4",
        "",
        "   ",
        &"j".repeat(65),
    ] {
        assert!(
            generated_video_destination(&root, hostile).is_err(),
            "'{hostile}' must not name a file"
        );
    }
    // A dot is refused too — nothing Slopus generates has one, and
    // allowing it is how a second extension gets in.
    assert!(generated_file_stem("job-01_A").is_ok());
    assert!(generated_file_stem("job.01").is_err());
}

#[test]
fn a_folder_that_holds_no_project_gets_no_writer() {
    // The same rule every other command that takes a folderPath follows:
    // confining a name against an unchecked folder confines nothing.
    let empty = tempfile::tempdir().unwrap();
    assert!(generated_video_destination(&empty.path().to_string_lossy(), "job-01").is_err());
    assert!(generated_video_destination("", "job-01").is_err());
}