Skip to content

AI media harness for planning, generating, and editing locally

TypeScript
22.0 KB
Raw Blame
use super::*;

#[test]
fn legacy_project_defaults_to_video_and_persists_its_type() {
    let root = tempfile::tempdir().unwrap();
    let legacy = include_str!("../../../fixtures/project-v1-created.json");
    assert!(serde_json::from_str::<serde_json::Value>(legacy)
        .unwrap()
        .get("generationType")
        .is_none());
    fs::write(root.path().join(PROJECT_FILE_NAME), legacy).unwrap();
    let opened = read_project(root.path()).unwrap();
    assert_eq!(opened.config.generation_type, GenerationType::Video);
    write_project(root.path(), &opened.config).unwrap();
    let saved: serde_json::Value =
        serde_json::from_slice(&fs::read(root.path().join(PROJECT_FILE_NAME)).unwrap()).unwrap();
    assert_eq!(saved["generationType"], "video");
}

#[test]
fn generation_types_survive_create_save_and_reopen() {
    for generation_type in ["video", "image", "3d", "music", "speech"] {
        let root = tempfile::tempdir().unwrap();
        let mut value = serde_json::to_value(created_fixture()).unwrap();
        value["generationType"] = serde_json::json!(generation_type);
        let config: ProjectConfig = serde_json::from_value(value).unwrap();
        let created = create_project_in(root.path(), &config).unwrap();
        let folder = Path::new(&created.folder_path);
        let opened = read_project(folder).unwrap();
        write_project(folder, &opened.config).unwrap();
        let reopened = read_project(folder).unwrap();
        assert_eq!(reopened.config.generation_type, config.generation_type);
        assert_eq!(
            serde_json::to_value(reopened.config).unwrap()["generationType"],
            generation_type
        );
    }
}

#[test]
fn invalid_explicit_generation_types_are_rejected() {
    for generation_type in [
        serde_json::Value::Null,
        serde_json::json!(""),
        serde_json::json!("unknown"),
        serde_json::json!("Video"),
        serde_json::json!(3),
    ] {
        let mut value = serde_json::to_value(created_fixture()).unwrap();
        value["generationType"] = generation_type;
        assert!(serde_json::from_value::<ProjectConfig>(value).is_err());
    }
}

#[test]
fn complete_project_create_open_save_reopen_is_lossless() {
    let root = tempfile::tempdir().unwrap();
    let expected = without_derived_project_state(validate_and_normalize_config(fixture()).unwrap());
    let created = create_project_in(root.path(), &expected).unwrap();
    assert_eq!(created.config, expected);

    let project_folder = PathBuf::from(&created.folder_path);
    let opened = read_project(&project_folder).unwrap();
    assert_eq!(opened.config, expected);

    let mut saved = opened.config.clone();
    saved.updated_at = "2026-02-03T04:05:06.000Z".into();
    write_project(&project_folder, &saved).unwrap();
    assert_eq!(read_project(&project_folder).unwrap().config, saved);

    let mut directories = Vec::new();
    fn collect_directories(root: &Path, current: &Path, output: &mut Vec<String>) {
        for entry in fs::read_dir(current).unwrap() {
            let path = entry.unwrap().path();
            if path.is_dir() {
                output.push(
                    path.strip_prefix(root)
                        .unwrap()
                        .to_string_lossy()
                        .replace('\\', "/"),
                );
                collect_directories(root, &path, output);
            }
        }
    }
    collect_directories(&project_folder, &project_folder, &mut directories);
    directories.sort();
    assert_eq!(
        directories,
        [
            "cache",
            "exports",
            "media",
            "media/generated",
            "media/imported",
            "references",
            "thumbnails",
        ]
    );
    let mut files: Vec<_> = fs::read_dir(&project_folder)
        .unwrap()
        .filter_map(Result::ok)
        .filter(|entry| entry.path().is_file())
        .map(|entry| entry.file_name().to_string_lossy().into_owned())
        .collect();
    files.sort();
    assert_eq!(files, [".generated-orphans-v1.json", PROJECT_FILE_NAME]);
}

#[test]
fn effect_bypass_round_trips_and_stays_absent_when_unset() {
    let mut config = fixture();
    let clip = &mut config.timeline.tracks[0].clips[0];
    clip.chroma_key = Some(ClipChromaKey {
        color: "#00ff00".into(),
        tolerance: 20.0,
        enabled: Some(false),
        ..Default::default()
    });
    clip.look = Some(ClipLook {
        opacity: 80.0,
        enabled: None,
    });
    let config = without_derived_project_state(validate_and_normalize_config(config).unwrap());
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let folder = PathBuf::from(&created.folder_path);
    write_project(&folder, &config).unwrap();
    assert_eq!(read_project(&folder).unwrap().config, config);
    let json = serde_json::to_value(&config).unwrap();
    let clip = &json["timeline"]["tracks"][0]["clips"][0];
    assert_eq!(clip["chromaKey"]["enabled"], false);
    // Unset stays unset: a project written before bypass keeps its shape.
    assert!(clip["look"].as_object().unwrap().get("enabled").is_none());
    // A file that carries the flag (written by the frontend) loads with it.
    let parsed: ClipLook = serde_json::from_str(r#"{"opacity":50,"temperature":10,"enabled":false}"#).unwrap();
    assert_eq!(parsed.enabled, Some(false));
    let legacy: ClipLook = serde_json::from_str(r#"{"opacity":50,"temperature":10}"#).unwrap();
    assert_eq!(legacy.enabled, None);
    assert_eq!(serde_json::to_value(&legacy).unwrap(), serde_json::json!({"opacity":50.0}));
}

#[test]
fn chroma_key_survives_save_and_reopen_and_validates_settings() {
    let mut config = fixture();
    config.timeline.tracks[0].clips[0].chroma_key = Some(ClipChromaKey {
        color: "#12ABef".into(),
        tolerance: 27.0,
        enabled: None,
        ..Default::default()
    });
    let config = without_derived_project_state(validate_and_normalize_config(config).unwrap());
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let folder = PathBuf::from(&created.folder_path);
    write_project(&folder, &config).unwrap();
    assert_eq!(read_project(&folder).unwrap().config, config);
    let json = serde_json::to_value(&config).unwrap();
    assert_eq!(
        json["timeline"]["tracks"][0]["clips"][0]["chromaKey"]["color"],
        "#12ABef"
    );
    for (color, tolerance) in [
        ("green", 20.0),
        ("#12345g", 20.0),
        ("#00ff00", -1.0),
        ("#00ff00", 101.0),
        ("#00ff00", f64::NAN),
    ] {
        let mut invalid = config.clone();
        invalid.timeline.tracks[0].clips[0].chroma_key = Some(ClipChromaKey {
            color: color.into(),
            tolerance,
            enabled: None,
            ..Default::default()
        });
        assert!(validate_and_normalize_config(invalid)
            .unwrap_err()
            .contains("chroma key"));
    }
    let mut removed = config.clone();
    removed.timeline.tracks[0].clips[0].chroma_key = None;
    write_project(&folder, &removed).unwrap();
    assert!(
        read_project(&folder).unwrap().config.timeline.tracks[0].clips[0]
            .chroma_key
            .is_none()
    );
}

#[test]
fn backdrop_key_controls_round_trip_and_reject_invalid_ranges() {
    let mut config = fixture();
    let key = serde_json::json!({"color":"#0000ff", "tolerance":20, "backdrop":"blue",
        "screenGain":110, "screenBalance":50, "clipBlack":5, "clipWhite":90,
        "despill":70, "unmix":80, "softness":1.5, "choke":-0.5,
        "removeShadows":true, "despeckle":true, "fillHoles":true});
    config.timeline.tracks[0].clips[0].chroma_key = Some(serde_json::from_value(key.clone()).unwrap());
    let config = without_derived_project_state(validate_and_normalize_config(config).unwrap());
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let folder = PathBuf::from(&created.folder_path);
    write_project(&folder, &config).unwrap();
    assert_eq!(read_project(&folder).unwrap().config, config);
    let restored = serde_json::to_value(&config.timeline.tracks[0].clips[0].chroma_key).unwrap();
    assert_eq!(restored["backdrop"], "blue");
    assert_eq!(restored["softness"], 1.5);
    assert_eq!(restored["fillHoles"], true);
    for (name, value) in [("backdrop", serde_json::json!("red")), ("clipBlack", serde_json::json!(90)),
        ("clipWhite", serde_json::json!(5)), ("screenGain", serde_json::json!(201)),
        ("despill", serde_json::json!(-1)), ("softness", serde_json::json!(5)), ("choke", serde_json::json!(-5))] {
        let mut invalid = config.clone();
        let mut invalid_key = key.clone();
        invalid_key[name] = value;
        invalid.timeline.tracks[0].clips[0].chroma_key = Some(serde_json::from_value(invalid_key).unwrap());
        assert!(validate_and_normalize_config(invalid).unwrap_err().contains("chroma key"));
    }
}

#[test]
fn deleting_a_project_removes_its_folder_and_every_file_inside_it() {
    let parent = tempfile::tempdir().unwrap();
    let project = project_folder_at(&parent.path().join("Disposable project"));
    fs::create_dir_all(project.join("media/generated")).unwrap();
    fs::write(project.join("media/generated/scene.mp4"), b"video").unwrap();
    let id = read_project(&project).unwrap().config.id;

    delete_project_folder(&project.to_string_lossy(), &id).unwrap();

    assert!(!project.exists());
    assert!(parent.path().is_dir());
}

#[test]
fn video_effects_survive_save_and_reopen() {
    let mut json = serde_json::to_value(fixture()).unwrap();
    let clip = &mut json["timeline"]["tracks"][0]["clips"][0];
    clip["sharpen"] = serde_json::json!({"amount": 60});
    clip["blur"] = serde_json::json!({"radius": 4});
    clip["colorCorrection"] = serde_json::json!({"exposure": 1, "brightness": -25, "contrast": 20, "saturation": 80});
    clip["vignette"] = serde_json::json!({"amount": 30});
    clip["lut"] = serde_json::json!({"intensity": 70, "table": {
        "name": "Identity", "size": 2, "domainMin": [0, 0, 0], "domainMax": [1, 1, 1],
        "values": [0,0,0, 1,0,0, 0,1,0, 1,1,0, 0,0,1, 1,0,1, 0,1,1, 1,1,1]
    }});
    let config = without_derived_project_state(
        validate_and_normalize_config(serde_json::from_value(json).unwrap()).unwrap(),
    );
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let folder = PathBuf::from(&created.folder_path);
    write_project(&folder, &config).unwrap();
    assert_eq!(read_project(&folder).unwrap().config, config);
    assert_eq!(config.timeline.tracks[0].clips[0].color_correction.as_ref().unwrap().brightness, Some(-25.0));
    for brightness in [-101.0, 101.0, f64::NAN, f64::INFINITY] {
        let mut invalid = config.clone();
        invalid.timeline.tracks[0].clips[0].color_correction.as_mut().unwrap().brightness = Some(brightness);
        assert!(validate_and_normalize_config(invalid).unwrap_err().contains("video effects"));
    }
    let mut legacy = serde_json::to_value(&config).unwrap();
    legacy["timeline"]["tracks"][0]["clips"][0]["colorCorrection"].as_object_mut().unwrap().remove("brightness");
    let legacy = validate_and_normalize_config(serde_json::from_value(legacy).unwrap()).unwrap();
    assert_eq!(legacy.timeline.tracks[0].clips[0].color_correction.as_ref().unwrap().brightness, None);
    let mut invalid = config.clone();
    invalid.timeline.tracks[0].clips[0]
        .lut
        .as_mut()
        .unwrap()
        .table
        .as_mut()
        .unwrap()
        .values
        .pop();
    assert!(validate_and_normalize_config(invalid)
        .unwrap_err()
        .contains("LUT table"));
    let mut invalid = config.clone();
    invalid.timeline.tracks[0].clips[0]
        .blur
        .as_mut()
        .unwrap()
        .radius = 25.0;
    assert!(validate_and_normalize_config(invalid)
        .unwrap_err()
        .contains("video effects"));
}

#[test]
fn project_look_and_extended_duration_survive_save_and_reopen() {
    let mut config = fixture();
    config.settings.default_look = Some("watercolor".into());
    config.brief.target_duration_seconds = 1800;
    let config = without_derived_project_state(validate_and_normalize_config(config).unwrap());
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let folder = PathBuf::from(&created.folder_path);
    assert_eq!(read_project(&folder).unwrap().config, config);
    let mut cleared = config;
    cleared.settings.default_look = None;
    write_project(&folder, &cleared).unwrap();
    assert_eq!(read_project(&folder).unwrap().config, cleared);
}

#[test]
fn deletion_refuses_a_different_project_identity_and_keeps_the_folder() {
    let parent = tempfile::tempdir().unwrap();
    let project = project_folder_at(&parent.path().join("Keep this project"));

    let error =
        delete_project_folder(&project.to_string_lossy(), "some-other-project").unwrap_err();

    assert!(error.contains("not the project selected for deletion"));
    assert!(project.is_dir());
    assert!(project.join(PROJECT_FILE_NAME).is_file());
}

#[test]
fn old_v1_documents_receive_empty_persistence_containers() {
    let mut value = serde_json::to_value(fixture()).unwrap();
    let object = value.as_object_mut().unwrap();
    object.remove("references");
    object.remove("generationJobs");
    object.remove("agentConversation");
    object.remove("providerSettings");
    let config: ProjectConfig = serde_json::from_value(value).unwrap();
    assert!(config.references.is_empty());
    assert!(config.generation_jobs.is_empty());
    assert!(config.agent_conversation.messages.is_empty());
    assert!(config.provider_settings.is_empty());
}

#[test]
fn replacement_failure_preserves_original_project_json() {
    let root = tempfile::tempdir().unwrap();
    let original = fixture();
    write_project(root.path(), &original).unwrap();
    let destination = root.path().join(PROJECT_FILE_NAME);
    let original_bytes = fs::read(&destination).unwrap();

    let mut changed = original.clone();
    changed.name = "This must not replace the original".into();
    let error = write_project_with_replacer(root.path(), &changed, |_, _| {
        Err(io::Error::new(
            io::ErrorKind::PermissionDenied,
            "simulated replacement failure",
        ))
    })
    .unwrap_err();

    assert!(error.contains("simulated replacement failure"));
    assert_eq!(fs::read(&destination).unwrap(), original_bytes);
    assert_eq!(
        read_project(root.path()).unwrap().config,
        without_derived_project_state(validate_and_normalize_config(original).unwrap())
    );
    assert_eq!(
        fs::read_dir(root.path())
            .unwrap()
            .filter_map(Result::ok)
            .filter(|entry| entry.path().is_file())
            .count(),
        1
    );
}

#[test]
fn new_project_uses_the_selected_empty_folder_itself() {
    let selected = tempfile::tempdir().unwrap();
    let expected_root = selected.path().canonicalize().unwrap();
    assert!(validate_empty_project_folder(selected.path()).is_ok());
    assert_eq!(fs::read_dir(selected.path()).unwrap().count(), 0);

    let created = create_project_at_with_references(selected.path(), &fixture(), &[]).unwrap();

    assert_eq!(
        PathBuf::from(created.folder_path).canonicalize().unwrap(),
        expected_root
    );
    assert!(selected.path().join(PROJECT_FILE_NAME).is_file());
    assert!(!selected
        .path()
        .join(safe_folder_name(&created.config.name))
        .exists());
}

#[test]
fn new_project_rejects_a_nonempty_selected_folder_without_changing_it() {
    let selected = tempfile::tempdir().unwrap();
    let existing = selected.path().join("keep.txt");
    fs::write(&existing, b"user data").unwrap();
    assert!(validate_empty_project_folder(selected.path()).unwrap_err().contains("not empty"));

    let error = create_project_at_with_references(selected.path(), &fixture(), &[]).unwrap_err();

    assert!(error.contains("not empty"), "unexpected error: {error}");
    assert_eq!(fs::read(&existing).unwrap(), b"user data");
    assert!(!selected.path().join(PROJECT_FILE_NAME).exists());
}

#[test]
fn project_mutation_rejects_broken_relational_ids() {
    let mut config = fixture();
    config.generation_jobs[0]
        .reference_ids
        .push("missing-reference".into());
    assert!(validate_and_normalize_config(config)
        .unwrap_err()
        .contains("unknown reference"));
}

#[test]
fn a_project_file_only_yields_media_a_hand_edit_cannot_widen() {
    let access = MediaAccess::default();
    // Belt and braces for the direction the allow-list alone cannot cover:
    // a HAND-EDITED project file naming something that is not media. The
    // path is recorded, so the allow-list passes — the extension check is
    // what refuses it.
    let root = tempfile::tempdir().unwrap();
    let secret = root.path().join("id_rsa");
    fs::write(&secret, b"private key").unwrap();

    let mut config = created_fixture();
    config.assets.push(ProjectAsset {
        id: "asset-crafted".into(),
        kind: "video".into(),
        name: "Not a clip".into(),
        relative_path: None,
        source_path: Some(external_source_path(&secret).unwrap()),
        mime_type: "video/mp4".into(),
        duration_ms: None,
        width: None,
        height: None,
        has_audio: None,
        motion: None, image_generation: None, image_editing: None, scene_segments: None,
        image_draft: None,
        parent_asset_id: None,
        created_at: config.created_at.clone(),
    });
    let created = create_project_in(root.path(), &config).unwrap();
    let recorded = created.config.assets[0].source_path.clone().unwrap();
    let error = external_media_bytes(&access, &created.folder_path, &recorded).unwrap_err();
    assert!(
        error.contains("not a media file"),
        "unexpected error: {error}"
    );
}

#[test]
fn the_settings_file_is_slopus_json_and_the_older_names_still_open() {
    assert_eq!(PROJECT_FILE_NAME, "slopus.json");
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &fixture()).unwrap();
    let folder = PathBuf::from(&created.folder_path);
    assert!(folder.join("slopus.json").is_file());

    // Every older name still opens, one folder per name, because a project
    // written by an earlier build must not become unopenable.
    for legacy in LEGACY_PROJECT_FILE_NAMES {
        let old = root.path().join(format!("old-{legacy}"));
        fs::create_dir(&old).unwrap();
        fs::copy(folder.join(PROJECT_FILE_NAME), old.join(legacy)).unwrap();
        assert_eq!(
            read_project(&old).unwrap().config,
            created.config,
            "a project stored as {legacy} failed to open"
        );
        // Saving migrates the name and leaves the old file where it is, so
        // the build that wrote it can still read the project.
        write_project(&old, &created.config).unwrap();
        assert!(old.join(PROJECT_FILE_NAME).is_file());
        assert!(old.join(legacy).is_file());
        // The new name wins once both exist.
        assert_eq!(project_file_in(&old), old.join(PROJECT_FILE_NAME));
    }
}

#[test]
fn blank_brief_is_a_valid_empty_project() {
    let mut config = fixture();
    config.brief.prompt.clear();
    config.generation_jobs.clear();
    assert!(validate_and_normalize_config(config).is_ok());
}

#[test]
fn color_grading_round_trips_and_validates() {
    let mut json = serde_json::to_value(fixture()).unwrap();
    let clip = &mut json["timeline"]["tracks"][0]["clips"][0];
    clip["colorCorrection"] = serde_json::json!({"exposure":1.0,"contrast":20.0,"saturation":80.0,"temperature":25.0,"tint":-15.0,"highlights":-20.0,"shadows":30.0,"whites":10.0,"blacks":-10.0});
    clip["creative"] = serde_json::json!({"look":"Warm Film","intensity":65.0,"fadedFilm":10.0,"sharpen":35.0,"vibrance":-15.0,"enabled":false});
    clip["curves"] = serde_json::json!({"rgb":[[0.0,0.0],[0.5,0.7],[1.0,1.0]],"red":[[0.0,0.1],[1.0,0.9]],"green":[[0.0,0.0],[1.0,1.0]],"blue":[[0.0,0.0],[1.0,1.0]],"hueVsSat":[[0.0,0.5],[0.2,0.8],[1.0,0.5]],"hueVsHue":[[0.0,0.5],[1.0,0.5]],"hueVsLuma":[[0.0,0.5],[1.0,0.5]],"lumaVsSat":[[0.0,0.2],[1.0,0.8]],"satVsSat":[[0.0,0.5],[1.0,0.5]]});
    clip["colorWheels"] = serde_json::json!({"shadows":{"x":0.3,"y":-0.4,"lightness":10.0},"midtones":{"x":0.0,"y":0.0,"lightness":-20.0},"highlights":{"x":0.2,"y":0.1,"lightness":30.0}});
    clip["vignette"] = serde_json::json!({"amount":-30.0,"midpoint":20.0,"roundness":-15.0,"feather":65.0});
    let config = without_derived_project_state(validate_and_normalize_config(serde_json::from_value(json.clone()).unwrap()).unwrap());
    // Compare serialized effects too: equality of two Rust structs alone would miss dropped fields.
    let serialized = serde_json::to_value(&config).unwrap();
    for effect in ["colorCorrection", "creative", "curves", "colorWheels", "vignette"] {
        assert_eq!(serialized["timeline"]["tracks"][0]["clips"][0][effect], json["timeline"]["tracks"][0]["clips"][0][effect]);
    }
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let folder = PathBuf::from(&created.folder_path);
    write_project(&folder, &config).unwrap();
    assert_eq!(read_project(&folder).unwrap().config, config);
    for (effect, field, value) in [
        ("colorCorrection", "temperature", serde_json::json!(101)),
        ("colorCorrection", "shadows", serde_json::json!(-101)),
        ("creative", "look", serde_json::json!("unknown")),
        ("creative", "vibrance", serde_json::json!(101)),
        ("vignette", "feather", serde_json::json!(-1)),
        ("curves", "rgb", serde_json::json!([])),
        ("curves", "rgb", serde_json::json!([[0,0],[0,1]])),
        ("curves", "hueVsHue", serde_json::json!([[0,0.1],[1,0.9]])),
        ("colorWheels", "shadows", serde_json::json!({"x":1,"y":1,"lightness":0})),
    ] {
        let mut invalid = json.clone();
        invalid["timeline"]["tracks"][0]["clips"][0][effect][field] = value;
        assert!(validate_and_normalize_config(serde_json::from_value(invalid).unwrap()).is_err(), "{effect}.{field}");
    }
}