Skip to content

AI media harness for planning, generating, and editing locally

TypeScript
8.3 KB
Raw Blame
use super::*;

#[test]
fn bundled_runtime_accepts_optional_preview_callback() {
    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(crate::slopfab::DLL_FILE_NAME);
    let api = Api::load(&path).unwrap();
    // Optional symbol loading must not hide a stale bundled binary.
    unsafe {
        let library = libloading::Library::new(&path).unwrap();
        assert!(library.get::<unsafe extern "C" fn()>(b"slopfab_request_set_preview\0").is_ok());
    }
    let request = RequestHandle::new(&api).unwrap();
    unsafe extern "C" fn callback(_: *const raw::Preview, _: *mut std::ffi::c_void) {}
    api.inner.set_preview(request.pointer.as_ptr(), Path::new("missing-taeh3.safetensors"), callback, std::ptr::null_mut()).unwrap();
    assert!(api.resolve(&request).is_ok(), "optional preview weights must not block planning");
}

#[test]
fn bundled_runtime_exposes_saved_latent_upscale_and_decode() {
    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(crate::slopfab::DLL_FILE_NAME);
    Api::load(&path).unwrap().require_saved_latent_upscale().unwrap();
}

#[test]
fn continuation_lock_overlap_can_be_enabled_and_disabled() {
    // Exercise the bundled runtime, including when a running app holds an older staged DLL.
    let path = Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("../../lib/slopfab")
        .join(crate::slopfab::DLL_FILE_NAME);
    let api = Api::load(&path).unwrap();
    let request = RequestHandle::new(&api).unwrap();
    api.set_frames(&request, 48).unwrap();
    api.set_resolution(&request, 64, 32).unwrap();
    api.set_continuation_lock_overlap(&request, true).unwrap();
    // Enabling the constraint requires an attached continuation source.
    assert!(api.resolve(&request).err().unwrap().contains("continuation"));
    api.set_continuation_lock_overlap(&request, false).unwrap();
    assert!(api.resolve(&request).is_ok());
}

#[test]
fn image_edit_setters_use_original_pixel_boxes_and_pad_the_plan() {
    let api = Api::load(&crate::slopfab::default_dll_path()).unwrap();
    let request = RequestHandle::new(&api).unwrap();
    let pixels = vec![100; 65 * 41 * 3];
    api.set_image_edit_rgb(&request, &pixels, 65, 41, [60, 35, 5, 6], 1.0, 0).unwrap();
    let plan = api.resolve(&request).unwrap();
    assert_eq!((plan.canvas_width, plan.canvas_height, plan.aligned_frames), (96, 64, 1));
    assert!(api.set_image_edit_rgb(&request, &pixels, 65, 41, [60, 35, 6, 6], 1.0, 0).is_err());
    assert!(api.set_image_edit_rgb(&request, &pixels[..3], 65, 41, [0, 0, 5, 6], 1.0, 0).is_err());
    assert!(api.set_image_edit_rgb(&request, &pixels, 65, 41, [60, 35, 5, 6], 1.0, -1).is_err());
    assert_eq!(api.resolve(&request).unwrap().canvas_width, 96);
    let folder = tempfile::tempdir().unwrap();
    let path = folder.path().join("source.png");
    image::RgbImage::from_raw(65, 41, pixels).unwrap().save(&path).unwrap();
    let from_path = RequestHandle::new(&api).unwrap();
    api.set_image_edit_path(&from_path, &path, [0, 0, 65, 41], 1.0, 16).unwrap();
    std::fs::remove_file(path).unwrap(); // The setter snapshots pixels synchronously.
    assert_eq!(api.resolve(&from_path).unwrap().aligned_frames, 1);
}

#[test]
fn older_runtimes_reject_outpainting_instead_of_editing_the_original() {
    let mut api = Api::load(&crate::slopfab::default_dll_path()).unwrap();
    api.disable_outpainting_for_test();
    let request = RequestHandle::new(&api).unwrap();
    api.set_image_edit_rgb(&request, &vec![127; 64 * 64 * 3], 64, 64, [16, 16, 32, 32], 1.0, 0).unwrap();
    assert!(api.set_image_edit_invert_mask(&request).unwrap_err().contains("API 1.20"));
    // Ordinary image editing remains available on older runtimes.
    assert!(api.resolve(&request).is_ok());
}

#[test]
fn older_runtimes_reject_requested_zoom_refinement() {
    let mut api = Api::load(&crate::slopfab::default_dll_path()).unwrap();
    api.disable_outpaint_refinement_for_test();
    let request = RequestHandle::new(&api).unwrap();
    api.set_image_edit_rgb(&request, &vec![127; 64 * 64 * 3], 64, 64, [16, 16, 32, 32], 1.0, 0).unwrap();
    api.set_image_edit_invert_mask(&request).unwrap();
    assert!(api.set_outpaint_blend_overlap(&request, 9).unwrap_err().contains("API 1.28"));
    assert!(api.set_outpaint_langevin_steps(&request, 5).unwrap_err().contains("API 1.28"));
}

#[test]
fn older_runtimes_report_missing_lora_preparation_without_breaking_planning() {
    let mut api = Api::load(&crate::slopfab::default_dll_path()).unwrap();
    api.disable_lora_preparation_for_test();
    assert!(api
        .prepare_lora_grid(Path::new("adapter.safetensors"), 2688, false)
        .unwrap_err()
        .contains("API 1.13"));
    let request = RequestHandle::new(&api).unwrap();
    api.set_frames(&request, 48).unwrap();
    assert!(api.resolve(&request).is_ok());
}

#[test]
fn requests_retain_the_library_and_reject_cross_instance_calls() {
    let path = crate::slopfab::default_dll_path();
    let first = Api::load(&path).unwrap();
    let request = RequestHandle::new(&first).unwrap();
    let second = Api::load(&path).unwrap();
    assert!(second
        .set_prompt(&request, "wrong library instance")
        .is_err());
    drop(first);
    request
        .api
        .set_prompt(&request, "retained library")
        .unwrap();
    request.api.set_frames(&request, 48).unwrap();
    request.api.set_resolution(&request, 736, 416).unwrap();
    assert!(request.api.resolve(&request).unwrap().aligned_frames > 0);
}

#[test]
fn reference_registries_are_independent_sessions() {
    use crate::slopfab::references::ReferenceVideos;
    let first = ReferenceVideos::default();
    let second = ReferenceVideos::default();
    let id = first
        .create_reference_video(2.0, &Default::default())
        .unwrap();
    assert!(second
        .append_reference_video(&id, &[0; 16], 2, 2, 0.0)
        .is_err());
    first
        .append_reference_video(&id, &[0; 16], 2, 2, 0.0)
        .unwrap();
    first.release_reference_videos(&[id.clone()]).unwrap();
    assert!(first
        .append_reference_video(&id, &[0; 16], 2, 2, 1.0)
        .is_err());
}

#[test]
fn older_runtimes_reject_latent_upscale_but_allow_normal_generation() {
    let mut api = Api::load(&crate::slopfab::default_dll_path()).unwrap();
    api.disable_latent_upscaler_for_test();
    let request = RequestHandle::new(&api).unwrap();
    assert!(api.set_latent_upscaler(&request, Some(Path::new("upscaler.safetensors"))).unwrap_err().contains("API 1.24"));
    api.set_latent_upscaler(&request, None).unwrap();
    api.set_frames(&request, 48).unwrap();
    api.set_resolution(&request, 64, 32).unwrap();
    assert!(api.resolve(&request).is_ok());
}

#[test]
fn older_runtimes_reject_cfg_and_cross_instance_guidance_is_refused() {
    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(crate::slopfab::DLL_FILE_NAME);
    let mut api = Api::load(&path).unwrap();
    api.disable_image_guidance_for_test();
    let request = RequestHandle::new(&api).unwrap();
    assert!(api.set_image_guidance(&request, 3.0, "watermark").unwrap_err().contains("API 1.30"));
    let other = Api::load(&path).unwrap();
    assert!(other.set_image_guidance(&request, 3.0, "watermark").unwrap_err().contains("different runtime"));
}

#[test]
fn pixel_masks_validate_buffers_and_reject_older_runtimes() {
    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../lib/slopfab").join(crate::slopfab::DLL_FILE_NAME);
    let api = Api::load(&path).unwrap();
    let request = RequestHandle::new(&api).unwrap();
    api.set_image_edit_rgb(&request, &vec![100; 64 * 32 * 3], 64, 32, [0, 0, 64, 32], 1.0, 0).unwrap();
    assert!(api.set_image_edit_mask(&request, &[255; 8], 64, 32).is_err());
    assert!(api.set_image_edit_mask(&request, &vec![255; 32 * 32], 32, 32).is_err());
    let mut mask = vec![0; 64 * 32]; mask[100] = 255; mask[101] = 128;
    api.set_image_edit_mask(&request, &mask, 64, 32).unwrap();
    mask.fill(0); // The native request owns a snapshot.
    api.resolve(&request).unwrap();
    let other = Api::load(&path).unwrap();
    assert!(other.set_image_edit_mask(&request, &mask, 64, 32).is_err());
    let mut older = Api::load(&path).unwrap(); older.disable_image_mask_for_test();
    let old_request = RequestHandle::new(&older).unwrap();
    assert!(older.set_image_edit_mask(&old_request, &mask, 64, 32).unwrap_err().contains("API 1.32"));
}