856f865cf98d
tests.rs
use std::cell::RefCell;
use std::collections::VecDeque;
use std::rc::Rc;
use photocraft_engine::Session;
use super::*;
use crate::Services;
const SVG: &str = r#"<svg xmlns="http://www.w3.org/2000/svg" width="12" height="8"><rect width="12" height="8" fill="red"/></svg>"#;
type Saves = Rc<RefCell<VecDeque<Result<Vec<u8>, String>>>>;
type Calls = Rc<RefCell<Vec<ExternalSvgEditor>>>;
struct TestSession(Saves);
impl ExternalSvgSession for TestSession {
fn poll(&mut self) -> Option<Result<Vec<u8>, String>> {
self.0.borrow_mut().pop_front()
}
}
struct NativeTestSession(Saves, &'static str);
impl ExternalSvgSession for NativeTestSession {
fn poll(&mut self) -> Option<Result<Vec<u8>, String>> {
self.0.borrow_mut().pop_front()
}
fn poll_vector(&mut self) -> Option<Result<crate::ExternalVectorSave, String>> {
self.poll().map(|r| r.map(|bytes| crate::ExternalVectorSave { bytes, preview_svg: Some(self.1.as_bytes().to_vec()) }))
}
}
fn fixture() -> (Box<PhotocraftApp>, Saves, Calls) {
let saves = Saves::default();
let calls = Calls::default();
let (queue, launched) = (saves.clone(), calls.clone());
let services = Services {
open_external_svg: Some(Box::new(move |editor, bytes| {
assert_eq!(&*bytes.bytes, SVG.as_bytes());
launched.borrow_mut().push(editor);
Ok(Box::new(TestSession(queue.clone())))
})),
..Default::default()
};
let mut app = PhotocraftApp::new(Session::new(), services);
app.session.execute("file.new", json!({"width":64,"height":64})).unwrap();
photocraft_engine::file_cmds::place_bytes(&mut app.session, "Artwork.svg", SVG.as_bytes().to_vec(), None, &json!({"smartObject":true})).unwrap();
app.sync_views();
(app, saves, calls)
}
fn open(app: &mut PhotocraftApp) {
assert!(intercept(app, "layer.smartObjects.editContents", &json!({})).unwrap().unwrap()["deferred"].as_bool().unwrap());
}
#[test]
fn control_menu_invoke_preserves_svg_editor_choice_and_rejects_other_dialogs() {
let (mut app, saves, calls) = fixture();
open(&mut app);
let pending = app.smart_svg.pending.as_mut().unwrap();
pending.editor = Editor::Program;
pending.program = Some("synthetic-editor".into());
let before = app.session.active().unwrap().doc.clone();
let revision = app.session.active().unwrap().revision;
let history = app.session.active().unwrap().history.past_len();
let journal = app.session.journal.clone();
let view = (app.ui.views[0].center, app.ui.views[0].zoom);
let pending = app.smart_svg.pending.as_ref().unwrap();
let target = (pending.target.doc, pending.target.layer, pending.target.contents_id.clone(), pending.target.fingerprint.clone());
let svg = pending.target.svg.clone();
let program = pending.program.clone();
let internal_once = app.smart_svg.internal_once;
let authorizations = Rc::new(std::cell::Cell::new(0));
let authorized = authorizations.clone();
app.services.automation_command = Some(Box::new(move |_, _| {
authorized.set(authorized.get() + 1);
Ok(())
}));
let clipboard_reads = Rc::new(std::cell::Cell::new(0));
let reads = clipboard_reads.clone();
app.services.clipboard_get_image = Some(Box::new(move || {
reads.set(reads.get() + 1);
Ok(None)
}));
let ctx = egui::Context::default();
for id in ["layer.duplicate", "image.imageSize", "edit.paste", "view.zoomIn"] {
let (request, _) = crate::control::ControlRequest::new("ui.menu.invoke", json!({"id": id}));
let crate::control::Reply::Done(result) = crate::control::handle(&mut app, &ctx, &request) else { panic!("blocked menu call must return immediately") };
assert_eq!(result["ok"], false, "{id}: {result}");
assert!(result.to_string().contains("modal dialog"));
assert_eq!(authorizations.get(), 0);
assert_eq!(clipboard_reads.get(), 0);
assert!(calls.borrow().is_empty());
assert!(saves.borrow().is_empty());
assert!(app.smart_svg.editing.is_empty());
assert_eq!(app.smart_svg.internal_once, internal_once);
assert!(!app.dialog_open());
let state = app.session.active().unwrap();
assert_eq!(state.doc, before);
assert_eq!(state.revision, revision);
assert_eq!(state.history.past_len(), history);
assert_eq!(app.session.journal, journal);
assert_eq!((app.ui.views[0].center, app.ui.views[0].zoom), view);
let pending = app.smart_svg.pending.as_ref().unwrap();
assert_eq!((pending.target.doc, pending.target.layer, pending.target.contents_id.clone(), pending.target.fingerprint.clone()), target);
assert!(Arc::ptr_eq(&pending.target.svg, &svg));
assert_eq!(&**pending.target.svg, SVG.as_bytes());
assert!(pending.editor == Editor::Program);
assert_eq!(pending.program, program);
}
}
#[test]
fn routing_keeps_automation_non_svg_and_unrelated_commands_internal() {
let (mut app, _, calls) = fixture();
assert!(intercept(&mut app, "edit.copy", &json!({})).is_none());
assert!(intercept(&mut app, "layer.smartObjects.editContents", &json!({"other":true})).is_none());
app.automation_input = true;
assert!(intercept(&mut app, "layer.smartObjects.editContents", &json!({})).is_none());
app.automation_input = false;
let st = app.session.active_mut().unwrap();
let layer = st.active_layer.unwrap();
let LayerContent::Smart(smart) = &mut Arc::make_mut(&mut st.doc).layer_mut(layer).unwrap().content else { panic!("smart") };
smart.source = SmartSource::Embedded { file_name: "Embedded.pcraft".into(), bytes: Arc::new(vec![]) };
assert!(intercept(&mut app, "layer.smartObjects.editContents", &json!({})).is_none());
assert!(calls.borrow().is_empty());
}
#[test]
fn svg_source_without_svg_filename_still_opens_editor_choice() {
let (mut app, _, calls) = fixture();
let st = app.session.active_mut().unwrap();
let layer = st.active_layer.unwrap();
let LayerContent::Smart(smart) = &mut Arc::make_mut(&mut st.doc).layer_mut(layer).unwrap().content else { panic!("smart") };
let SmartSource::Embedded { file_name, .. } = &mut smart.source else { panic!("embedded") };
*file_name = "Unknown clipboard object".into();
open(&mut app);
assert!(calls.borrow().is_empty());
}
#[test]
fn prompt_and_escape_never_launch_or_change_document() {
let (mut app, _, calls) = fixture();
let before = app.session.active().unwrap().doc.clone();
open(&mut app);
open(&mut app);
let ctx = app.ctx().clone();
// A second pass of the frame finds the dialog open and opens no other.
host(&mut app, &ctx);
host(&mut app, &ctx);
assert_eq!(app.framework.dialogs.stack().ids().count(), 1, "one editor-choice dialog");
let id = app.smart_svg.dialog.expect("the dialog's id is kept");
assert!(app.smart_svg.modal_open());
// Escape, the close box and Cancel all end in the framework's cancel.
let _ = crate::dialogs::cancel(&mut app, &ctx, id);
assert!(!app.smart_svg.modal_open(), "the choice is dropped");
assert!(app.smart_svg.dialog.is_none());
host(&mut app, &ctx);
assert_eq!(app.framework.dialogs.stack().ids().count(), 0, "a cancelled choice does not reopen");
assert!(calls.borrow().is_empty());
assert_eq!(app.session.active().unwrap().doc, before);
}
#[test]
fn manual_internal_choice_uses_existing_child_document_flow() {
let (mut app, _, calls) = fixture();
let parent = app.session.active().unwrap().doc.id;
open(&mut app);
app.smart_svg.pending.as_mut().unwrap().editor = Editor::Internal;
confirm(&mut app).unwrap();
assert_ne!(app.session.active().unwrap().doc.id, parent);
assert_eq!(app.session.smart_links.len(), 1);
assert!(calls.borrow().is_empty());
assert!(!app.smart_svg.internal_once);
}
/// Edit Contents again on contents already open in the internal editor switches to that
/// document, as it does for any smart object, instead of an error.
#[test]
fn edit_contents_again_switches_to_the_open_internal_copy() {
let (mut app, _, calls) = fixture();
let parent = app.session.active_index().unwrap();
open(&mut app);
app.smart_svg.pending.as_mut().unwrap().editor = Editor::Internal;
confirm(&mut app).unwrap();
let child = app.session.active().unwrap().doc.id;
app.session.set_active(parent);
app.run("layer.smartObjects.editContents", json!({})).unwrap();
assert_eq!(app.session.active().unwrap().doc.id, child);
assert_eq!(app.session.smart_links.len(), 1);
assert!(app.smart_svg.pending.is_none());
assert!(!app.ui.status_error, "{}", app.ui.status);
assert!(calls.borrow().is_empty());
}
#[test]
fn missing_external_service_keeps_internal_edit_and_save_back() {
let (mut app, saves, calls) = fixture();
app.services.open_external_svg = None;
let parent_index = app.session.active_index().unwrap();
let st = app.session.active().unwrap();
let (parent, layer, before, history) = (st.doc.id, st.active_layer.unwrap(), st.doc.clone(), st.history.past_len());
let opened = app.run("layer.smartObjects.editContents", json!({})).unwrap();
assert_eq!(opened["document"].as_u64(), app.session.active_index().map(|index| index as u64));
assert_ne!(app.session.active().unwrap().doc.id, parent);
assert_eq!(app.session.smart_links.len(), 1);
let link = &app.session.smart_links[0];
assert_eq!((link.parent, link.layer, link.child), (parent, layer, app.session.active().unwrap().doc.id));
assert!(!app.smart_svg.modal_open());
assert!(app.smart_svg.editing.is_empty());
assert!(calls.borrow().is_empty());
assert!(saves.borrow().is_empty());
app.run("layer.new.layer", json!({})).unwrap();
app.session
.edit("paint child", |doc, active| {
let bounds = doc.bounds();
doc.layer_mut(active.unwrap()).unwrap().surface_mut().unwrap().fill_rect(bounds, &[0.0, 1.0, 0.0, 1.0]);
Ok(())
})
.unwrap();
app.run("layer.smartObjects.saveContents", json!({})).unwrap();
assert!(!app.session.active().unwrap().is_dirty());
app.session.set_active(parent_index);
let st = app.session.active().unwrap();
let LayerContent::Smart(smart) = &st.doc.layer(layer).unwrap().content else { panic!("smart") };
let SmartSource::Embedded { file_name, bytes } = &smart.source else { panic!("embedded") };
assert!(file_name.ends_with(".pcraft"));
assert_ne!(&**bytes, SVG.as_bytes());
assert_eq!(smart.cache.as_ref().unwrap().rgba(32, 32), [0.0, 1.0, 0.0, 1.0]);
assert_eq!(st.history.past_len(), history + 1);
assert!(!app.smart_svg.modal_open());
assert!(calls.borrow().is_empty());
assert!(saves.borrow().is_empty());
app.run("edit.undo", json!({})).unwrap();
assert_eq!(app.session.active().unwrap().doc, before);
}
#[test]
fn choosing_internal_editor_ends_existing_external_session() {
let (mut app, _, _) = fixture();
open(&mut app);
confirm(&mut app).unwrap();
assert_eq!(app.smart_svg.editing.len(), 1);
open(&mut app);
app.smart_svg.pending.as_mut().unwrap().editor = Editor::Internal;
confirm(&mut app).unwrap();
assert!(app.smart_svg.editing.is_empty());
assert_eq!(app.session.smart_links.len(), 1);
}
#[test]
fn failed_launch_is_visible_and_keeps_source_unchanged() {
let (mut app, _, _) = fixture();
app.services.open_external_svg = Some(Box::new(|_, _| Err("Editor not installed".into())));
let before = app.session.active().unwrap().doc.clone();
open(&mut app);
assert_eq!(confirm(&mut app).unwrap_err(), "Editor not installed");
assert!(app.smart_svg.editing.is_empty());
assert_eq!(app.session.active().unwrap().doc, before);
}
#[test]
fn selected_editor_and_repeated_saves_update_with_undo_and_preserve_selection() {
let (mut app, saves, calls) = fixture();
let before = app.session.active().unwrap().doc.clone();
let target = app.session.active().unwrap().active_layer;
open(&mut app);
app.smart_svg.pending.as_mut().unwrap().editor = Editor::Illustrator;
confirm(&mut app).unwrap();
assert!(matches!(calls.borrow().first(), Some(ExternalSvgEditor::Illustrator)));
app.session.execute("layer.new.layer", json!({})).unwrap();
let selection = app.session.active().unwrap().active_layer;
let ctx = egui::Context::default();
saves.borrow_mut().push_back(Ok(SVG.replace("red", "blue").into_bytes()));
poll(&mut app, &ctx);
let blue = app.session.active().unwrap().doc.clone();
assert_ne!(blue, before);
assert_ne!(selection, target);
assert_eq!(app.session.active().unwrap().active_layer, selection);
saves.borrow_mut().push_back(Ok(SVG.replace("red", "green").into_bytes()));
poll(&mut app, &ctx);
assert_ne!(app.session.active().unwrap().doc, blue);
assert_eq!(app.smart_svg.editing.len(), 1);
app.session.execute("edit.undo", json!({})).unwrap();
assert_eq!(app.session.active().unwrap().doc, blue);
app.session.execute("edit.undo", json!({})).unwrap();
app.session.execute("edit.undo", json!({})).unwrap();
assert_eq!(app.session.active().unwrap().doc, before);
}
#[test]
fn saved_changes_wait_on_document_switch_and_active_preview() {
let (mut app, saves, _) = fixture();
let parent = app.session.active().unwrap().doc.id;
open(&mut app);
confirm(&mut app).unwrap();
app.session.execute("file.new", json!({"width":32,"height":32})).unwrap();
let other = app.session.active().unwrap().doc.clone();
saves.borrow_mut().push_back(Ok(SVG.replace("red", "blue").into_bytes()));
let ctx = egui::Context::default();
poll(&mut app, &ctx);
assert_eq!(app.session.active().unwrap().doc, other);
assert!(app.smart_svg.editing.first().unwrap().saved.is_some());
let index = app.session.documents().iter().position(|st| st.doc.id == parent).unwrap();
app.session.set_active(index);
let open_dialog = app.framework.dialogs.open(craft::ui::dialog::StandardPrompt::custom("Hold on".to_owned()));
poll(&mut app, &ctx);
assert!(app.smart_svg.editing.first().unwrap().saved.is_some());
app.framework.dialogs.cancel_by_id(&ctx, open_dialog);
poll(&mut app, &ctx);
assert!(app.smart_svg.editing.first().unwrap().saved.is_none());
}
#[test]
fn changed_source_stops_syncing_instead_of_overwriting_user_edit() {
let (mut app, saves, _) = fixture();
open(&mut app);
confirm(&mut app).unwrap();
let target = &app.smart_svg.editing.first().unwrap().target;
app.session.execute("layer.smartObjects.updateSvg", json!({"document": target.doc.0,"layer": target.layer.0,"contentsId":target.contents_id,"fingerprint":target.fingerprint,"svg":SVG.replace("red","yellow")})).unwrap();
let before = app.session.active().unwrap().doc.clone();
saves.borrow_mut().push_back(Ok(SVG.replace("red", "blue").into_bytes()));
poll(&mut app, &egui::Context::default());
assert!(app.smart_svg.editing.is_empty());
assert!(app.ui.status_error);
assert_eq!(app.session.active().unwrap().doc, before);
}
#[test]
fn stale_prompt_never_launches_into_another_document_or_changed_source() {
for switched in [false, true] {
let (mut app, _, calls) = fixture();
open(&mut app);
if switched {
app.session.execute("file.new", json!({"width":32,"height":32})).unwrap();
} else {
let target = &app.smart_svg.pending.as_ref().unwrap().target;
app.session.execute("layer.smartObjects.updateSvg", json!({"document":target.doc.0,"layer":target.layer.0,"contentsId":target.contents_id,"fingerprint":target.fingerprint,"svg":SVG.replace("red","blue")})).unwrap();
}
assert!(confirm(&mut app).is_err());
assert!(calls.borrow().is_empty());
}
}
#[test]
fn malformed_and_transient_saves_can_recover_and_deleted_layer_stops_session() {
let (mut app, saves, _) = fixture();
open(&mut app);
confirm(&mut app).unwrap();
let before = app.session.active().unwrap().doc.clone();
saves.borrow_mut().push_back(Ok(vec![255]));
poll(&mut app, &egui::Context::default());
assert_eq!(app.smart_svg.editing.len(), 1);
assert_eq!(app.session.active().unwrap().doc, before);
saves.borrow_mut().push_back(Err("Editor is replacing its SVG file".into()));
poll(&mut app, &egui::Context::default());
assert_eq!(app.smart_svg.editing.len(), 1);
saves.borrow_mut().push_back(Ok(b"<svg><".to_vec()));
poll(&mut app, &egui::Context::default());
assert_eq!(app.smart_svg.editing.len(), 1);
assert_eq!(app.session.active().unwrap().doc, before);
saves.borrow_mut().push_back(Ok(SVG.replace("red", "blue").into_bytes()));
poll(&mut app, &egui::Context::default());
assert_ne!(app.session.active().unwrap().doc, before);
let st = app.session.active_mut().unwrap();
Arc::make_mut(&mut st.doc).layers.clear();
poll(&mut app, &egui::Context::default());
assert!(app.smart_svg.editing.is_empty());
}
#[test]
fn custom_executable_requires_explicit_selection() {
let (mut app, _, calls) = fixture();
open(&mut app);
app.smart_svg.pending.as_mut().unwrap().editor = Editor::Program;
assert!(confirm(&mut app).is_err());
assert!(calls.borrow().is_empty());
open(&mut app);
let pending = app.smart_svg.pending.as_mut().unwrap();
pending.editor = Editor::Program;
pending.program = Some("C:/synthetic/editor.exe".into());
confirm(&mut app).unwrap();
assert!(matches!(calls.borrow().first(), Some(ExternalSvgEditor::Program(path)) if path == "C:/synthetic/editor.exe"));
}
#[test]
fn idle_gradient_tool_does_not_block_svg_editing() {
let (mut app, _, calls) = fixture();
app.ui.tool = crate::state::Tool::Gradient;
open(&mut app);
confirm(&mut app).unwrap();
assert_eq!(calls.borrow().len(), 1);
}
#[test]
fn saved_changes_wait_on_idle_cam_box_then_resume_after_cancel() {
let (mut app, saves, calls) = fixture();
let smart_layer = app.session.active().unwrap().active_layer.unwrap();
open(&mut app);
confirm(&mut app).unwrap();
app.session.execute("layer.new.layer", json!({})).unwrap();
app.session.execute("select.rect", json!({"x":8,"y":8,"width":12,"height":8})).unwrap();
app.ui.tool = crate::state::Tool::ContentAwareMove;
assert!(crate::cam_transform::begin(&mut app, [8, 4]));
assert!(!crate::canvas::testing::in_gesture(&app) && app.patch_preview.is_none() && app.ui.transform.is_none());
let before = app.session.active().unwrap().doc.clone();
let revision = app.session.active().unwrap().revision;
let history = app.session.active().unwrap().history.past_len();
let raster_layer = app.session.active().unwrap().active_layer.unwrap();
let cam = app.ui.cam_transform.clone();
let blue = SVG.replace("red", "blue");
saves.borrow_mut().push_back(Ok(blue.as_bytes().to_vec()));
let ctx = egui::Context::default();
poll(&mut app, &ctx);
assert_eq!(app.session.active().unwrap().doc, before);
assert_eq!(app.session.active().unwrap().revision, revision);
assert_eq!(app.session.active().unwrap().history.past_len(), history);
assert_eq!(app.ui.cam_transform, cam);
assert!(app.smart_svg.editing.first().unwrap().saved.is_some());
assert!(saves.borrow().is_empty());
crate::cam_transform::cancel(&mut app);
poll(&mut app, &ctx);
let st = app.session.active().unwrap();
let LayerContent::Smart(smart) = &st.doc.layer(smart_layer).unwrap().content else { panic!("smart") };
let SmartSource::Embedded { bytes, .. } = &smart.source else { panic!("embedded") };
assert_eq!(&**bytes, blue.as_bytes());
assert_eq!(st.doc.layer(raster_layer), before.layer(raster_layer));
assert_eq!(st.doc.selection, before.selection);
assert_eq!(st.history.past_len(), history + 1);
assert!(app.ui.cam_transform.is_none());
assert!(app.smart_svg.editing.first().unwrap().saved.is_none());
assert_eq!(app.smart_svg.editing.len(), 1);
assert_eq!(calls.borrow().len(), 1);
}
#[test]
fn saved_changes_wait_on_mask_target_then_apply_without_another_save() {
let (mut app, saves, _) = fixture();
open(&mut app);
confirm(&mut app).unwrap();
let before = app.session.active().unwrap().doc.clone();
app.ui.mask_target = true;
saves.borrow_mut().push_back(Ok(SVG.replace("red", "blue").into_bytes()));
let ctx = egui::Context::default();
poll(&mut app, &ctx);
assert_eq!(app.session.active().unwrap().doc, before);
assert!(app.smart_svg.editing.first().unwrap().saved.is_some());
app.ui.mask_target = false;
poll(&mut app, &ctx);
assert_ne!(app.session.active().unwrap().doc, before);
}
#[test]
fn saved_changes_wait_on_implicit_mask_then_resume_without_another_save() {
let (mut app, saves, calls) = fixture();
open(&mut app);
confirm(&mut app).unwrap();
let st = app.session.active_mut().unwrap();
let layer = st.active_layer.unwrap();
Arc::make_mut(&mut st.doc).layer_mut(layer).unwrap().mask = Some(photocraft_doc::LayerMask::reveal_all());
st.channel_view.color_hidden = vec![true; photocraft_engine::channel_cmds::color_count(&st.doc)];
st.channel_view.alpha_visible.clear();
assert_eq!(st.channel_view.target, photocraft_engine::channel_cmds::ChannelTarget::Composite);
assert!(st.channel_view.layer_mask.is_none());
let before = st.doc.clone();
let revision = st.revision;
assert!(!app.ui.mask_target);
assert!(!app.session.tools.mask_targeted);
assert!(app.layer_mask_targeted());
let blue = SVG.replace("red", "blue");
saves.borrow_mut().push_back(Ok(blue.as_bytes().to_vec()));
let ctx = egui::Context::default();
poll(&mut app, &ctx);
assert_eq!(app.session.active().unwrap().doc, before);
assert_eq!(app.session.active().unwrap().revision, revision);
assert!(app.smart_svg.editing.first().unwrap().saved.is_some());
assert!(saves.borrow().is_empty());
app.session.active_mut().unwrap().channel_view.color_hidden.clear();
assert!(!app.layer_mask_targeted());
poll(&mut app, &ctx);
let st = app.session.active().unwrap();
assert_ne!(st.doc, before);
assert_eq!(st.doc.layer(layer).unwrap().mask, before.layer(layer).unwrap().mask);
let LayerContent::Smart(smart) = &st.doc.layer(layer).unwrap().content else { panic!("smart") };
let SmartSource::Embedded { bytes, .. } = &smart.source else { panic!("embedded") };
assert_eq!(&**bytes, blue.as_bytes());
assert!(app.smart_svg.editing.first().unwrap().saved.is_none());
assert_eq!(calls.borrow().len(), 1);
}
#[test]
fn explicit_mask_channel_roundtrip_resumes_queued_svg_save_with_masks_preserved() {
for channel in ["mask", "vectorMask"] {
let (mut app, saves, calls) = fixture();
open(&mut app);
confirm(&mut app).unwrap();
app.session.execute("layer.layerMask.revealAll", json!({})).unwrap();
app.session.execute("layer.vectorMask.revealAll", json!({})).unwrap();
let before = app.session.active().unwrap().doc.clone();
let layer = app.session.active().unwrap().active_layer.unwrap();
app.run("channel.target", json!({"channel":channel})).unwrap();
assert_eq!(app.ui.mask_target, channel == "mask");
assert_eq!(app.ui.vector_mask_target, channel == "vectorMask");
let blue = SVG.replace("red", "blue");
saves.borrow_mut().push_back(Ok(blue.as_bytes().to_vec()));
let ctx = egui::Context::default();
poll(&mut app, &ctx);
assert_eq!(app.session.active().unwrap().doc, before);
assert!(app.smart_svg.editing.first().unwrap().saved.is_some());
assert!(saves.borrow().is_empty());
app.run("channel.target", json!({"channel":"composite"})).unwrap();
assert!(!app.ui.mask_target);
assert!(!app.ui.vector_mask_target);
assert!(!app.session.tools.mask_targeted);
poll(&mut app, &ctx);
let st = app.session.active().unwrap();
let updated = st.doc.layer(layer).unwrap();
assert_eq!(updated.mask, before.layer(layer).unwrap().mask);
assert_eq!(updated.vector_mask, before.layer(layer).unwrap().vector_mask);
let LayerContent::Smart(smart) = &updated.content else { panic!("smart") };
let SmartSource::Embedded { bytes, .. } = &smart.source else { panic!("embedded") };
assert_eq!(&**bytes, blue.as_bytes());
assert!(app.smart_svg.editing.first().unwrap().saved.is_none());
assert_eq!(app.smart_svg.editing.len(), 1);
assert_eq!(calls.borrow().len(), 1);
}
}
#[test]
fn bounded_sessions_require_reuse_or_closing_a_document() {
let (mut app, _, calls) = fixture();
for _ in 0..MAX_SESSIONS {
open(&mut app);
confirm(&mut app).unwrap();
photocraft_engine::file_cmds::place_bytes(&mut app.session, "Artwork.svg", SVG.as_bytes().to_vec(), None, &json!({"smartObject":true})).unwrap();
}
open(&mut app);
assert!(confirm(&mut app).unwrap_err().contains("limit: 8"));
assert_eq!(calls.borrow().len(), MAX_SESSIONS);
assert_eq!(app.smart_svg.editing.len(), MAX_SESSIONS);
}
/// An AI payload in the PSD link table must reach explicit editor selection without becoming
/// a filesystem path. A saved SVG replaces it through the normal optimistic transaction.
#[test]
fn embedded_ai_link_table_handoff_preserves_source_until_saved_and_undo_restores_it() {
let (mut app, saves, calls) = fixture();
let id = app.session.active().unwrap().active_layer.unwrap();
let original = b"%PDF-1.6\nsynthetic vector".to_vec();
{
let doc = Arc::make_mut(&mut app.session.active_mut().unwrap().doc);
let payload = photocraft_io::linked::encode_linked_file(&photocraft_io::linked::LinkedFile {
uuid: "embedded-ai".into(),
file_name: "Logo.ai".into(),
bytes: original.clone(),
});
doc.metadata.psd_global_blocks.push((*b"8BIM", *b"lnk2", Arc::new(payload)));
let LayerContent::Smart(sm) = &mut doc.layer_mut(id).unwrap().content else { panic!("smart") };
sm.source = SmartSource::Linked { path: "embedded-ai".into() };
}
let before = app.session.active().unwrap().doc.clone();
let queue = saves.clone();
app.services.open_external_svg = Some(Box::new(move |editor, source| {
assert_eq!(editor, ExternalSvgEditor::VectorCraft);
assert_eq!(*source.bytes, original);
assert_eq!(source.extension, "ai");
// An empty, same-size preview is admissible and yields a real
// "nothing to draw" warning from the native update command.
let empty_preview = r#"<svg xmlns="http://www.w3.org/2000/svg" width="12" height="8"/>"#;
Ok(Box::new(NativeTestSession(queue.clone(), empty_preview)))
}));
open(&mut app);
assert!(calls.borrow().is_empty());
confirm(&mut app).unwrap();
assert_eq!(app.session.active().unwrap().doc, before);
app.ui.notices.clear();
saves.borrow_mut().push_back(Ok(b"%PDF-1.6\nedited native AI".to_vec()));
poll(&mut app, &egui::Context::default());
assert_eq!(app.ui.notices.len(), 1);
let notice = &app.ui.notices[0];
assert!(notice.title.contains("Vector"), "{notice:?}");
assert_eq!(notice.tone, craft::theme::variant::Tone::Neutral);
assert!(notice.lines.iter().any(|line| line.contains("nothing to draw")));
let layer = app.session.active().unwrap().doc.layer(id).unwrap();
assert!(
matches!(&layer.content,LayerContent::Smart(sm) if matches!(&sm.source,SmartSource::Embedded {file_name,bytes} if file_name=="Logo.ai" && bytes.as_slice()==b"%PDF-1.6\nedited native AI"))
);
assert!(app.session.undo());
assert_eq!(app.session.active().unwrap().doc, before);
}
#[test]
fn saved_changes_wait_through_quick_mask_and_resume_without_another_save() {
let (mut app, saves, _) = fixture();
open(&mut app);
confirm(&mut app).unwrap();
app.run("select.editInQuickMaskMode", json!({"on":true})).unwrap();
let before = app.session.active().unwrap().doc.clone();
saves.borrow_mut().push_back(Ok(SVG.replace("red", "blue").into_bytes()));
let ctx = egui::Context::default();
poll(&mut app, &ctx);
assert_eq!(app.session.active().unwrap().doc, before);
assert!(app.smart_svg.editing.first().unwrap().saved.is_some());
app.run("select.editInQuickMaskMode", json!({"on":false})).unwrap();
poll(&mut app, &ctx);
assert!(app.smart_svg.editing.first().unwrap().saved.is_none());
let st = app.session.active().unwrap();
let photocraft_doc::LayerContent::Smart(sm) = &st.doc.layer(st.active_layer.unwrap()).unwrap().content else { panic!("smart object") };
let photocraft_doc::SmartSource::Embedded { bytes, .. } = &sm.source else { panic!("embedded") };
assert_eq!(bytes.as_slice(), SVG.replace("red", "blue").as_bytes());
}
struct FinishedSession(Option<Result<Vec<u8>, String>>);
impl ExternalSvgSession for FinishedSession {
fn poll(&mut self) -> Option<Result<Vec<u8>, String>> {
self.0.take()
}
fn finished(&self) -> bool {
true
}
}
#[test]
fn cancelled_desktop_choosers_release_session_capacity_without_changing_content() {
let (mut app, _, _) = fixture();
app.services.open_external_svg = Some(Box::new(|_, _| Ok(Box::new(FinishedSession(Some(Err("Editor selection cancelled".into())))))));
let before = app.session.active().unwrap().doc.clone();
let ctx = egui::Context::default();
for _ in 0..MAX_SESSIONS + 1 {
open(&mut app);
confirm(&mut app).unwrap();
poll(&mut app, &ctx);
assert!(app.smart_svg.editing.is_empty());
assert_eq!(app.session.active().unwrap().doc, before);
}
}
#[test]
fn finished_session_retains_final_save_until_target_is_safe() {
let (mut app, _, _) = fixture();
app.services.open_external_svg = Some(Box::new(|_, _| Ok(Box::new(FinishedSession(Some(Ok(SVG.replace("red", "blue").into_bytes())))))));
open(&mut app);
confirm(&mut app).unwrap();
let ctx = egui::Context::default();
app.run("select.editInQuickMaskMode", json!({"on":true})).unwrap();
let before = app.session.active().unwrap().doc.clone();
poll(&mut app, &ctx);
assert_eq!(app.smart_svg.editing.len(), 1);
assert!(app.smart_svg.editing[0].saved.is_some());
assert_eq!(app.session.active().unwrap().doc, before);
app.run("select.editInQuickMaskMode", json!({"on":false})).unwrap();
poll(&mut app, &ctx);
assert_ne!(app.session.active().unwrap().doc, before);
poll(&mut app, &ctx);
assert!(app.smart_svg.editing.is_empty());
}
#[test]
fn external_svg_save_back_reports_omissions_once_and_keeps_silent_updates_quiet() {
for omitted in [false, true] {
let (mut app, saves, _) = fixture();
open(&mut app);
app.smart_svg.pending.as_mut().unwrap().editor = Editor::Illustrator;
confirm(&mut app).unwrap();
app.ui.notices.clear();
let before = app.session.active().unwrap().doc.clone();
let child = if omitted { "<image width='2' height='2' href='data:image/png,%00'/>" } else { "" };
let svg = SVG.replace("red", "blue").replace("</svg>", &format!("{child}</svg>"));
saves.borrow_mut().push_back(Ok(svg.into_bytes()));
let ctx = egui::Context::default();
poll(&mut app, &ctx);
assert_ne!(app.session.active().unwrap().doc, before);
assert_eq!(app.smart_svg.editing.len(), 1, "the session keeps the successful new fingerprint");
if omitted {
assert_eq!(app.ui.notices.len(), 1);
assert!(app.ui.notices[0].title.contains("SVG"));
assert!(app.ui.notices[0].lines.iter().any(|line| line.contains("embedded") && line.contains("omitted")));
assert_eq!(app.ui.notices[0].tone, craft::theme::variant::Tone::Neutral);
} else {
assert!(app.ui.notices.is_empty(), "{:?}", app.ui.notices);
}
let notices = app.ui.notices.clone();
poll(&mut app, &ctx);
assert_eq!(app.ui.notices, notices, "polling the same completed save cannot duplicate a warning");
app.session.execute("edit.undo", json!({})).unwrap();
assert_eq!(app.session.active().unwrap().doc, before);
}
}
#[test]
fn svg_save_back_displays_omitted_image_warning() {
let (mut app, saves, _) = fixture();
open(&mut app);
confirm(&mut app).unwrap();
let omitted = SVG.replace("</svg>", r#"<image width="2" height="2" href="data:image/png,broken"/></svg>"#);
saves.borrow_mut().push_back(Ok(omitted.into_bytes()));
poll(&mut app, &egui::Context::default());
assert!(app.smart_svg.editing.first().unwrap().saved.is_none());
assert!(app.ui.notices.iter().any(|notice| notice.lines.iter().any(|line| line.contains("embedded") && line.contains("omitted"))));
}
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.