diff --git a/crates/ui/src/esign/coderabbit_repro.rs b/crates/ui/src/esign/coderabbit_repro.rs new file mode 100644 index 000000000..98414fb75 --- /dev/null +++ b/crates/ui/src/esign/coderabbit_repro.rs @@ -0,0 +1,180 @@ +//! Regression tests for the CodeRabbit findings reviewed on PR #661, +//! reproduced against ef496161 (storytold/craft-libs#661). +//! +//! Reuses `review_repro`'s `Hold` backend and helpers: a test chooses when, +//! and in what order, a held request is answered. + +use craft_esign::{Envelope, EnvelopeStatus}; + +use super::review_repro::{envelope_for, ready, send, who}; +use super::*; + +/// A document's revision changing is itself a context change: a reply for +/// the bytes under the old `document_etag` must not install under the new +/// one, even though the document id never changed. +#[test] +fn stale_create_reply_for_old_revision_is_dropped_after_reopen_with_new_etag() { + let (mut dialog, hold) = ready(); + dialog.open("doc-A".into(), "A.pdf".into(), Some("etag-1".into()), who("alice")); + send(&mut dialog, b"A bytes etag1"); + dialog.open("doc-A".into(), "A.pdf".into(), Some("etag-2".into()), who("alice")); + + let (_, create) = hold.take(|r| matches!(r, Request::Create { .. })); + create.answer(Answer::Created(envelope_for("doc-A", "alice"))); + dialog.pump(1.0); + + assert!( + dialog.envelope.is_none(), + "stale reply for etag-1 installed into the etag-2 opening: {:?}", + dialog.envelope.as_ref().map(|e| e.id.clone()) + ); +} + +/// `take_send_request` already handed the application doc-A's draft; the +/// dialog then reopens for doc-B before the application calls +/// `submit_request`. The reply this produces must still be tagged with +/// doc-A's context, not doc-B's. +#[test] +fn create_reply_for_a_request_taken_before_reopening_does_not_install_in_the_new_document() { + let (mut dialog, hold) = ready(); + dialog.open("doc-A".into(), "A.pdf".into(), None, who("alice")); + dialog.add_email("bob@example.com".into()); + dialog.queue_send(); + let out = dialog.take_send_request().expect("send produced a request"); + + // The dialog moves on before the application gets around to submitting + // what it already took. + dialog.open("doc-B".into(), "B.pdf".into(), None, who("alice")); + dialog.submit_request(Request::Create { draft: Box::new(out.draft), document: b"A bytes".to_vec(), idempotency_key: out.idempotency_key, send: true }); + + let (_, create) = hold.take(|r| matches!(r, Request::Create { .. })); + create.answer(Answer::Created(envelope_for("doc-A", "alice"))); + dialog.pump(1.0); + + assert!( + dialog.envelope.is_none(), + "doc-A's envelope, submitted after reopening doc-B, installed into doc-B's dialog: {:?}", + dialog.envelope.as_ref().map(|e| e.id.clone()) + ); +} + +/// An untaken `SendRequest` is specific to the context that queued it; it +/// must not survive into a reopened dialog for another document. +#[test] +fn an_untaken_send_request_does_not_survive_reopening_for_another_document() { + let (mut dialog, _hold) = ready(); + dialog.open("doc-A".into(), "A.pdf".into(), None, who("alice")); + dialog.add_email("bob@example.com".into()); + dialog.queue_send(); + + dialog.open("doc-B".into(), "B.pdf".into(), None, who("alice")); + + assert!(dialog.take_send_request().is_none(), "doc-B's dialog still held doc-A's untaken send request"); +} + +/// `note_create_result` is the synchronous twin of `submit_request`: an app +/// that handles create itself, rather than through the backend channel, +/// reports the outcome here. It must drop a result for a context the dialog +/// has already left, exactly as a channel reply would. +#[test] +fn note_create_result_for_a_previous_document_does_not_install_in_the_reopened_dialog() { + let (mut dialog, _hold) = ready(); + dialog.open("doc-A".into(), "A.pdf".into(), None, who("alice")); + dialog.add_email("bob@example.com".into()); + dialog.queue_send(); + let _out = dialog.take_send_request().expect("send produced a request"); + + dialog.open("doc-B".into(), "B.pdf".into(), None, who("alice")); + dialog.note_create_result(Ok(envelope_for("doc-A", "alice"))); + + assert!( + dialog.envelope.is_none(), + "doc-A's result, reported after reopening doc-B, installed into doc-B's dialog: {:?}", + dialog.envelope.as_ref().map(|e| e.id.clone()) + ); +} + +/// `Replier::dup` is the only way a backend can answer one sequence twice. +/// The dialog answers the first reply normally, but a second reply for the +/// same (already resolved) sequence must drop unconditionally, not reach +/// the match arms with no context left to check against. +#[test] +fn a_duplicated_answer_for_an_already_resolved_sequence_is_dropped() { + let (mut dialog, hold) = ready(); + dialog.open("doc-A".into(), "A.pdf".into(), None, who("alice")); + send(&mut dialog, b"A bytes"); + + let (_, create) = hold.take(|r| matches!(r, Request::Create { .. })); + let dup = create.dup(); + create.answer(Answer::Created(envelope_for("doc-A", "alice"))); + dialog.pump(1.0); + assert_eq!(dialog.envelope.as_ref().map(|e| e.id.clone()), Some("env-doc-A".to_owned()), "the first answer should have installed normally"); + + // The dialog moves on; a backend still holding `dup` from the first + // request answers it again. + dialog.open("doc-B".into(), "B.pdf".into(), None, who("alice")); + dup.answer(Answer::Created(envelope_for("doc-A", "alice"))); + dialog.pump(2.0); + + let shown = dialog.envelope.as_ref().and_then(|e| e.document_id.clone()); + assert!( + shown.is_none() || shown.as_deref() == Some("doc-B"), + "a duplicate answer for the first request reinstalled doc-A's envelope into doc-B's dialog: {shown:?}" + ); +} + +/// `busy` belongs to whichever operation is still pending. A lookup that +/// fails while a create is genuinely in flight must not report the create +/// as finished. +#[test] +fn a_failed_lookup_does_not_clear_busy_for_a_pending_create() { + let (mut dialog, hold) = ready(); + dialog.open("doc-A".into(), "A.pdf".into(), None, who("alice")); + send(&mut dialog, b"A bytes"); + assert!(dialog.busy, "queue_send should have left the dialog busy"); + + dialog.query = "ca".into(); + dialog.query_changed_at = 0.0; + dialog.maybe_lookup(1.0); + let (_, lookup) = hold.take(|r| matches!(r, Request::Lookup { .. })); + lookup.refuse("lookup failed"); + dialog.pump(2.0); + + assert!(dialog.busy, "a failed lookup cleared busy while the create for doc-A was still pending"); +} + +/// Two "Refresh status" clicks before either reply arrives race two +/// `Request::Status` calls. If the older one answers after the newer one +/// already installed, it must not overwrite the newer status. +#[test] +fn an_older_status_reply_does_not_overwrite_a_newer_one() { + let (mut dialog, hold) = ready(); + dialog.open("doc-A".into(), "A.pdf".into(), None, who("alice")); + send(&mut dialog, b"A bytes"); + let (_, create) = hold.take(|r| matches!(r, Request::Create { .. })); + create.answer(Answer::Created(envelope_for("doc-A", "alice"))); + dialog.pump(1.0); + let env_id = dialog.envelope.as_ref().expect("created").id.clone(); + + dialog.busy = true; + let seq1 = dialog.submit_in_context(Request::Status { envelope: env_id.clone() }); + dialog.pending_op_seq = Some(seq1); + dialog.status_seq = seq1; + dialog.busy = true; + let seq2 = dialog.submit_in_context(Request::Status { envelope: env_id.clone() }); + dialog.pending_op_seq = Some(seq2); + dialog.status_seq = seq2; + + let (_, status1) = hold.take(|r| matches!(r, Request::Status { .. })); + let (_, status2) = hold.take(|r| matches!(r, Request::Status { .. })); + + // The newer request (seq2) answers first. + status2.answer(Answer::Status(Envelope { status: EnvelopeStatus::Completed, ..envelope_for("doc-A", "alice") })); + dialog.pump(2.0); + assert_eq!(dialog.envelope.as_ref().map(|e| e.status), Some(EnvelopeStatus::Completed)); + + // The older request (seq1), issued first, answers last. + status1.answer(Answer::Status(Envelope { status: EnvelopeStatus::Sent, ..envelope_for("doc-A", "alice") })); + dialog.pump(3.0); + assert_eq!(dialog.envelope.as_ref().map(|e| e.status), Some(EnvelopeStatus::Completed), "an older status reply overwrote a newer one"); +} diff --git a/crates/ui/src/esign/mod.rs b/crates/ui/src/esign/mod.rs index c9f404583..1301e4ffd 100644 --- a/crates/ui/src/esign/mod.rs +++ b/crates/ui/src/esign/mod.rs @@ -14,6 +14,8 @@ use egui::{Context, RichText, Ui}; mod backend; #[cfg(test)] +mod coderabbit_repro; +#[cfg(test)] mod review_repro; pub use backend::{Answer, EsignBackend, Replier, Request}; @@ -27,15 +29,24 @@ const RETRY: f64 = 20.0; type Inbox = (u64, Result); -/// What dialog state a reply belongs to: which document, under which -/// signed-in account. A reply installs only when this still matches the -/// dialog's current context; see [`EsignDialog::submit_in_context`] and -/// [`EsignDialog::pump`]. Deliberately excludes incidental UI state such as -/// search text, which changes without the dialog meaning something new. +/// What dialog state a reply belongs to: which document revision, under +/// which signed-in account, opened which time. A reply installs only when +/// this still matches the dialog's current context; see +/// [`EsignDialog::submit_in_context`] and [`EsignDialog::pump`]. Deliberately +/// excludes incidental UI state such as search text, which changes without +/// the dialog meaning something new. +/// +/// `opening` is bumped every time [`EsignDialog::open`] actually changes +/// something (document, revision or account). `document_etag` alone would +/// already separate two revisions of the same document id, but it cannot +/// separate "document A, closed, then A opened again" from the first +/// opening: both carry the same id and the same etag. `opening` does. #[derive(Clone, Debug, PartialEq, Eq)] struct EsignContext { document_id: String, + document_etag: Option, account: Option, + opening: u64, } /// Every string the dialog shows. @@ -57,6 +68,9 @@ pub struct EsignLabels { pub no_service: String, pub sign_in_first: String, pub need_recipient: String, + /// Shown instead of adding the person, when a search match has no email + /// address the provider can invite. + pub contact_missing_email: String, pub status: String, pub void: String, pub remind: String, @@ -83,6 +97,7 @@ impl Default for EsignLabels { no_service: "Signatures cannot be requested here.".into(), sign_in_first: "Sign in to request signatures.".into(), need_recipient: "Add at least one signer.".into(), + contact_missing_email: "This contact has no email address to invite.".into(), status: "Status".into(), void: "Void".into(), remind: "Remind".into(), @@ -120,6 +135,23 @@ pub struct EsignDialog { /// Context (document plus account) each in-flight context-sensitive /// request was issued under. Consulted, then removed, in [`Self::pump`]. contexts: HashMap, + /// Sequences whose context has already been consulted once in + /// [`Self::pump`], bounded to the most recent entries. A backend that + /// answers the same sequence twice (via [`Replier::dup`]) has its second + /// answer dropped unconditionally instead of re-entering the match arms + /// with no context to check. + consumed: std::collections::HashSet, + consumed_order: std::collections::VecDeque, + /// The sequence that currently owns `busy`, if any. An answer (success or + /// failure) for any other sequence must not clear `busy` on its behalf. + pending_op_seq: Option, + /// The most recently issued `Request::Status` sequence. An older status + /// reply that arrives after a newer one has already installed is + /// superseded and dropped. + status_seq: u64, + /// How many times [`Self::open`] has actually changed something. Part of + /// [`EsignContext`]; see its docs. + opening: u64, document_id: String, document_etag: Option, document_title: String, @@ -137,6 +169,12 @@ pub struct EsignDialog { error: Option, envelope: Option, send_out: Option, + /// The context [`Self::queue_send`] captured for the still-outstanding + /// [`SendRequest`], consumed by [`Self::submit_request`] or + /// [`Self::note_create_result`] so a reply is tagged with the context the + /// send was queued under, not whatever context is current when the + /// application finally submits it. + pending_send_context: Option, completed_bytes: Option>, account_fingerprint: Option, } @@ -159,6 +197,11 @@ impl Default for EsignDialog { rx, newest: 0, contexts: HashMap::new(), + consumed: std::collections::HashSet::new(), + consumed_order: std::collections::VecDeque::new(), + pending_op_seq: None, + status_seq: 0, + opening: 0, document_id: String::new(), document_etag: None, document_title: String::new(), @@ -176,12 +219,28 @@ impl Default for EsignDialog { error: None, envelope: None, send_out: None, + pending_send_context: None, completed_bytes: None, account_fingerprint: None, } } } +/// A send operation id no other send in this process has used, from a random +/// start so one saved by an earlier process is unlikely to repeat either. +/// Mirrors `docking::model::fresh_window_id`: a counter kept on one +/// [`EsignDialog`] repeats across two dialog instances (two windows, or one +/// replaced after a document closes), and two sends sharing an idempotency +/// key have a conforming provider return the first envelope for the second. +fn fresh_send_id() -> u64 { + use std::hash::{BuildHasher, Hasher}; + use std::sync::OnceLock; + use std::sync::atomic::{AtomicU64, Ordering}; + static NEXT: OnceLock = OnceLock::new(); + let next = NEXT.get_or_init(|| AtomicU64::new(std::collections::hash_map::RandomState::new().build_hasher().finish() >> 1)); + next.fetch_add(1, Ordering::Relaxed) +} + impl EsignDialog { pub fn new() -> EsignDialog { EsignDialog::default() @@ -213,17 +272,29 @@ impl EsignDialog { let fingerprint = format!("{}@{}", sender.id, sender.email.as_deref().unwrap_or("")); let account_changed = self.account_fingerprint.as_deref() != Some(fingerprint.as_str()); let document_changed = self.document_id != document_id; - if account_changed || document_changed { + let revision_changed = self.document_etag != document_etag; + if account_changed || document_changed || revision_changed { self.recipients.clear(); self.message.clear(); self.envelope = None; self.completed_bytes = None; self.error = None; self.draft_idempotency_key = None; + // A's fields must never reappear as B's: see the Major finding + // this guards against. + self.placements.clear(); + // An untaken send request was built for the context being left; + // drop it so a later `take_send_request` cannot hand the + // application A's draft to submit under B's dialog. + // `pending_send_context`, captured once the request is taken, is + // deliberately left alone here: see its field doc. + self.send_out = None; + self.opening = self.opening.wrapping_add(1); // Any job still in flight was issued for the context being left. // Its reply will be dropped in `pump` (context no longer // matches), so nothing will ever clear `busy` on its behalf. self.busy = false; + self.pending_op_seq = None; } self.account_fingerprint = Some(fingerprint); self.document_id = document_id; @@ -242,6 +313,10 @@ impl EsignDialog { /// Field placements the app prepared (page-normalised). Replaces any prior set. pub fn set_placements(&mut self, placements: Vec) { self.placements = placements; + // Same reasoning as `add_contact`/`add_email`/removing a recipient: the + // fields a retried create would send have changed, so a key from + // before this call must not be reused for them. + self.draft_idempotency_key = None; } /// What Send asked the application to encode and submit, if anything. @@ -251,8 +326,20 @@ impl EsignDialog { /// Submit a request through the host backend (for example after the app /// encoded document bytes for a [`SendRequest`]). + /// + /// Tags the reply with the context [`Self::queue_send`] captured when it + /// built the [`SendRequest`] being submitted, not whatever context is + /// current now. The application can encode bytes, or the dialog can be + /// reopened for another document or account, before this runs; a reply + /// for a [`SendRequest`] built under a now-abandoned context must drop in + /// [`Self::pump`] exactly as one issued under that context would, not + /// install under whichever context happens to be current when this is + /// finally called. pub fn submit_request(&mut self, request: Request) { - let _ = self.submit_in_context(request); + let context = self.pending_send_context.take().unwrap_or_else(|| self.current_context()); + let seq = self.submit(request); + self.contexts.insert(seq, context); + self.pending_op_seq = Some(seq); } /// Completed document bytes after a successful download request. @@ -261,8 +348,19 @@ impl EsignDialog { } /// Tell the dialog create/send finished (or failed) after the app submitted. + /// + /// Gated the same way as [`Self::submit_request`]: when a context was + /// captured for the outstanding send, a result reported after the + /// dialog moved on to another document or account is dropped instead of + /// installing under the new context. pub fn note_create_result(&mut self, result: Result) { + if let Some(context) = self.pending_send_context.take() + && context != self.current_context() + { + return; + } self.busy = false; + self.pending_op_seq = None; match result { Ok(env) => { self.envelope = Some(env); @@ -284,9 +382,15 @@ impl EsignDialog { seq } - /// The context (document plus account) a reply must still match to install. + /// The context (document revision plus account, plus which opening) a + /// reply must still match to install. See [`EsignContext`]. fn current_context(&self) -> EsignContext { - EsignContext { document_id: self.document_id.clone(), account: self.account_fingerprint.clone() } + EsignContext { + document_id: self.document_id.clone(), + document_etag: self.document_etag.clone(), + account: self.account_fingerprint.clone(), + opening: self.opening, + } } /// Like [`Self::submit`], but tags the request with the dialog's current @@ -301,24 +405,51 @@ impl EsignDialog { seq } + /// Remembers that `seq`'s context has already been consulted once in + /// [`Self::pump`], bounded to the most recently consulted sequences. A + /// backend that answers the same sequence twice (only possible through + /// [`Replier::dup`]) has its second answer dropped unconditionally, + /// instead of reaching the match arms with no context left to check. + fn remember_consumed(&mut self, seq: u64) { + const TRACKED: usize = 64; + if self.consumed_order.len() >= TRACKED + && let Some(oldest) = self.consumed_order.pop_front() + { + self.consumed.remove(&oldest); + } + self.consumed_order.push_back(seq); + self.consumed.insert(seq); + } + fn pump(&mut self, now: f64) { while let Ok((seq, result)) = self.rx.try_recv() { - if self.caps_seq == Some(seq) { + let is_caps_reply = self.caps_seq == Some(seq); + if is_caps_reply { self.caps_seq = None; } + if self.consumed.contains(&seq) { + continue; + } // A context-tagged reply installs only for the context that // issued it; it drops silently for any other, including a - // document switch or an account switch. Typing in the signer - // search bumps `newest` and is not a context change, so it no - // longer gates a create/status/completed/void/remind reply: the - // rule here is context equality, nothing else. - if let Some(context) = self.contexts.remove(&seq) - && context != self.current_context() - { - continue; + // document switch, a revision change or an account switch. + // Typing in the signer search bumps `newest` and is not a + // context change, so it no longer gates a create/status/ + // completed/void/remind reply: the rule here is context + // equality, nothing else. + if let Some(context) = self.contexts.remove(&seq) { + self.remember_consumed(seq); + if context != self.current_context() { + continue; + } } match result { - Ok(Answer::Capabilities { capabilities, responsible_party, linked }) => { + // Guarded by `is_caps_reply`, computed before the swap + // above cleared it: a reply from a backend `set_backend` + // already replaced carries a sequence that is not (or no + // longer) `caps_seq`, so it cannot overwrite capabilities, + // responsible or linked for the new backend. + Ok(Answer::Capabilities { capabilities, responsible_party, linked }) if is_caps_reply => { self.capabilities = Some(capabilities); self.responsible = Some(responsible_party); self.linked = linked; @@ -327,27 +458,48 @@ impl EsignDialog { self.matches = contacts; self.looking = false; } - Ok(Answer::Created(env)) | Ok(Answer::Status(env)) => { + Ok(Answer::Created(env)) => { self.busy = false; + self.pending_op_seq = None; + self.envelope = Some(env); + self.error = None; + } + // Guarded by `status_seq`, the most recently issued status + // request: two "Refresh status" clicks in flight at once can + // answer out of order, and the older one must not overwrite + // state a newer one already installed. + Ok(Answer::Status(env)) if seq == self.status_seq => { + self.busy = false; + self.pending_op_seq = None; self.envelope = Some(env); self.error = None; } Ok(Answer::Completed(doc)) => { self.busy = false; + self.pending_op_seq = None; self.completed_bytes = Some(doc.bytes); self.error = None; } Ok(Answer::Voided { .. }) => { self.busy = false; + self.pending_op_seq = None; if let Some(env) = self.envelope.as_mut() { env.status = EnvelopeStatus::Voided; } } Ok(Answer::Reminded { .. }) => { self.busy = false; + self.pending_op_seq = None; } + // Clears `busy` only when this failure belongs to the + // operation that currently owns it: a lookup failing (or a + // superseded status request failing) must not wrongly + // report a still-running create as finished. Err(reason) => { - self.busy = false; + if self.pending_op_seq == Some(seq) { + self.busy = false; + self.pending_op_seq = None; + } self.looking = false; self.error = Some(reason); } @@ -381,7 +533,15 @@ impl EsignDialog { } fn add_contact(&mut self, contact: Contact) { - let email = contact.email.clone().unwrap_or_else(|| contact.id.clone()); + // `Contact::id` is the provider's share identifier, decided by + // `target`, and is not promised to be an address: `craft_cloud` + // documents the two as distinct and warns against treating one as + // the other. Falling back to it here would hand the envelope create + // request a recipient email that is not an email. + let Some(email) = contact.email.clone() else { + self.error = Some(self.labels.contact_missing_email.clone()); + return; + }; if self.recipients.iter().any(|r| r.email.eq_ignore_ascii_case(&email)) { return; } @@ -431,12 +591,13 @@ impl EsignDialog { expires: None, }; if self.draft_idempotency_key.is_none() { - self.draft_idempotency_key = Some(format!("esign-{}-{}", self.document_id, self.seq.saturating_add(1))); + self.draft_idempotency_key = Some(format!("esign-{}-{}", self.document_id, fresh_send_id())); } let idempotency_key = self.draft_idempotency_key.clone().unwrap_or_default(); self.busy = true; self.error = None; self.send_out = Some(SendRequest { draft, idempotency_key }); + self.pending_send_context = Some(self.current_context()); } /// Draw the dialog when open. Call every frame (even when closed) so @@ -480,6 +641,13 @@ impl EsignDialog { return; } + if !self.linked { + // Send is disabled below without saying why; the compose form is + // the one place an unlinked user sees before reaching it. + ui.label(&self.labels.sign_in_first); + ui.add_space(4.0); + } + ui.label(RichText::new(&self.document_title).strong()); ui.add_space(4.0); @@ -562,18 +730,21 @@ impl EsignDialog { && let Some(r) = env.recipients.iter().find(|r| r.status == RecipientStatus::Pending) { self.busy = true; - let _ = self.submit_in_context(Request::Remind { envelope: env.id.clone(), recipient: r.id.clone() }); + let seq = self.submit_in_context(Request::Remind { envelope: env.id.clone(), recipient: r.id.clone() }); + self.pending_op_seq = Some(seq); } if caps.contains(&EsignCapability::Void) && env.status == EnvelopeStatus::Sent && ui.add_enabled(!self.busy, egui::Button::new(&self.labels.void)).clicked() { self.busy = true; - let _ = self.submit_in_context(Request::Void { envelope: env.id.clone(), reason: "voided by sender".into() }); + let seq = self.submit_in_context(Request::Void { envelope: env.id.clone(), reason: "voided by sender".into() }); + self.pending_op_seq = Some(seq); } if env.status == EnvelopeStatus::Completed && ui.add_enabled(!self.busy, egui::Button::new(&self.labels.download)).clicked() { self.busy = true; - let _ = self.submit_in_context(Request::Completed { envelope: env.id.clone() }); + let seq = self.submit_in_context(Request::Completed { envelope: env.id.clone() }); + self.pending_op_seq = Some(seq); } if ui.button(&self.labels.close).clicked() { self.open = false; @@ -581,7 +752,9 @@ impl EsignDialog { }); if ui.button("Refresh status").clicked() { self.busy = true; - let _ = self.submit_in_context(Request::Status { envelope: env.id.clone() }); + let seq = self.submit_in_context(Request::Status { envelope: env.id.clone() }); + self.pending_op_seq = Some(seq); + self.status_seq = seq; } } } @@ -645,4 +818,89 @@ mod tests { assert_eq!(req.draft.recipients.len(), 1); assert_eq!(req.draft.recipients[0].email, "bob@example.com"); } + + /// The texts egui drew, walking into `Shape::Vec` groups the way widgets nest them. Same + /// pattern as `docking::native_tests::texts`. + fn texts(shapes: &[egui::epaint::ClippedShape]) -> Vec { + fn walk(shape: &egui::Shape, out: &mut Vec) { + match shape { + egui::Shape::Vec(shapes) => shapes.iter().for_each(|s| walk(s, out)), + egui::Shape::Text(text) => out.push(text.galley.text().to_owned()), + _ => {} + } + } + let mut out = Vec::new(); + shapes.iter().for_each(|clipped| walk(&clipped.shape, &mut out)); + out + } + + #[test] + fn compose_form_shows_sign_in_message_when_not_linked() { + let mut dialog = EsignDialog { + capabilities: Some(vec![EsignCapability::Envelopes]), + document_title: "A.pdf".into(), + linked: false, + ..Default::default() + }; + let ctx = Context::default(); + let full = ctx.run_ui(egui::RawInput::default(), |ui| dialog.ui(ui)); + let shown = texts(&full.shapes); + assert!(shown.iter().any(|t| t == &dialog.labels.sign_in_first), "sign-in message not shown for an unlinked account: {shown:?}"); + } + + fn ada() -> Identity { + Identity { id: "u".into(), display: "Ada".into(), email: Some("ada@example.com".into()), avatar: None } + } + + fn placement() -> FieldPlacement { + FieldPlacement { role: "Signer".into(), page: 0, x: 0.1, y: 0.2, w: 0.3, h: 0.05, kind: "signature".into(), required: true } + } + + #[test] + fn add_contact_rejects_a_contact_with_no_email() { + let mut dialog = EsignDialog::default(); + let contact = + Contact { id: "share-id-123".into(), target: craft_cloud::ShareTarget::User("share-id-123".into()), name: "Mallory".into(), email: None, avatar: None, is_group: false }; + dialog.add_contact(contact); + assert!(dialog.recipients.is_empty(), "a contact with no email became a recipient: {:?}", dialog.recipients); + assert_eq!(dialog.error.as_deref(), Some(dialog.labels.contact_missing_email.as_str())); + } + + #[test] + fn set_placements_invalidates_the_idempotency_key() { + let mut dialog = EsignDialog { linked: true, sender: Some(ada()), ..Default::default() }; + dialog.add_email("bob@example.com".into()); + dialog.queue_send(); + let first = dialog.take_send_request().expect("first send").idempotency_key; + + dialog.set_placements(vec![placement()]); + dialog.queue_send(); + let second = dialog.take_send_request().expect("second send").idempotency_key; + + assert_ne!(first, second, "changing placements kept the old idempotency key: {first}"); + } + + #[test] + fn placements_do_not_survive_a_document_change() { + let mut dialog = EsignDialog::default(); + dialog.open("doc-A".into(), "A.pdf".into(), None, ada()); + dialog.set_placements(vec![placement()]); + + dialog.open("doc-B".into(), "B.pdf".into(), None, ada()); + + assert!(dialog.placements.is_empty(), "doc-B inherited doc-A's placements: {:?}", dialog.placements); + } + + #[test] + fn queue_send_keys_are_unique_across_dialog_instances() { + fn send_key(doc: &str) -> String { + let mut dialog = EsignDialog { linked: true, sender: Some(ada()), document_id: doc.into(), ..Default::default() }; + dialog.add_email("bob@example.com".into()); + dialog.queue_send(); + dialog.take_send_request().expect("send").idempotency_key + } + let a = send_key("doc-A"); + let b = send_key("doc-A"); + assert_ne!(a, b, "two fresh dialog instances for the same document produced the same idempotency key: {a}"); + } } diff --git a/crates/ui/src/esign/review_repro.rs b/crates/ui/src/esign/review_repro.rs index 452fdfefc..c9780d7e5 100644 --- a/crates/ui/src/esign/review_repro.rs +++ b/crates/ui/src/esign/review_repro.rs @@ -12,8 +12,10 @@ use craft_esign::{Envelope, EnvelopeStatus, EsignCapability}; use super::*; +/// Reused by `coderabbit_repro`, the regression tests for the CodeRabbit +/// findings reviewed on the same pull request. #[derive(Clone, Default)] -struct Hold(Arc>>); +pub(super) struct Hold(Arc>>); impl EsignBackend for Hold { fn submit(&self, request: Request, reply: Replier) { @@ -23,18 +25,18 @@ impl EsignBackend for Hold { impl Hold { /// Takes the oldest held request matching `pick`. - fn take(&self, pick: impl Fn(&Request) -> bool) -> (Request, Replier) { + pub(super) fn take(&self, pick: impl Fn(&Request) -> bool) -> (Request, Replier) { let mut held = self.0.lock().unwrap(); let i = held.iter().position(|(r, _)| pick(r)).expect("request was submitted"); held.remove(i) } } -fn who(id: &str) -> Identity { +pub(super) fn who(id: &str) -> Identity { Identity { id: id.into(), display: id.into(), email: Some(format!("{id}@example.com")), avatar: None } } -fn envelope_for(doc: &str, sender: &str) -> Envelope { +pub(super) fn envelope_for(doc: &str, sender: &str) -> Envelope { Envelope { id: format!("env-{doc}"), title: format!("Contract {doc}"), @@ -53,7 +55,7 @@ fn envelope_for(doc: &str, sender: &str) -> Envelope { } /// A dialog with a held backend whose capabilities probe has been answered. -fn ready() -> (EsignDialog, Hold) { +pub(super) fn ready() -> (EsignDialog, Hold) { let hold = Hold::default(); let mut dialog = EsignDialog::default(); dialog.set_backend(hold.clone()); @@ -70,7 +72,7 @@ fn ready() -> (EsignDialog, Hold) { } /// The app's Send path: queue_send -> take_send_request -> submit Create. -fn send(dialog: &mut EsignDialog, doc_bytes: &[u8]) { +pub(super) fn send(dialog: &mut EsignDialog, doc_bytes: &[u8]) { dialog.add_email("bob@example.com".into()); dialog.queue_send(); let out = dialog.take_send_request().expect("Send produced a request");