Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_mail/tests/sync_engine.rs

123 KiB, 161 runs

created by r1870400018:75213, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1//! The folder sync engine over a scripted [`MailSession`]: an in-memory model of an IMAP server
2//! whose capabilities choose the tier, with a log of every verb so each test can say which wire
3//! commands the engine used. The `NO-LOSS` and `RESET` laws are stated as unit tests here: an
4//! expunge on the server appears as vanished, a UIDVALIDITY change yields one generation and no
5//! duplicates, a replayed apply is a no-op, and a delta never undoes a pending local change.
6
7use oxedyne_fe2o3_core::prelude::*;
8use oxedyne_fe2o3_mail::sync::{
9 act,
10 apply,
11 date_year,
12 file_sent,
13 find_message_id,
14 link_key,
15 maildir_name,
16 parse_maildir_name,
17 save_draft,
18 sync_folder,
19 ActOutcome,
20 Action,
21 AppendUid,
22 Budget,
23 Caps,
24 CopyUid,
25 Cursor,
26 Delta,
27 Entry,
28 FetchChanged,
29 FetchWhat,
30 FetchedMessage,
31 Filed,
32 LinkKey,
33 MailSession,
34 MailboxInfo,
35 MailboxStatus,
36 MsgKey,
37 Provider,
38 Roles,
39 Saved,
40 SelectWith,
41 Snapshot,
42 SpecialUse,
43 SyncStore,
44 Target,
45 Tier,
46 UidSet,
47};
48
49use std::collections::BTreeMap;
50
51
52// ┌───────────────────────────────────────────────────────────────────────────┐
53// │ THE SCRIPTED SERVER │
54// └───────────────────────────────────────────────────────────────────────────┘
55
56#[derive(Clone, Debug)]
57struct Msg {
58 uid: u32,
59 flags: Vec<String>,
60 raw: Vec<u8>,
61 modseq: u64,
62 gm: u64,
63}
64
65#[derive(Clone, Debug, Default)]
66struct Folder {
67 attrs: Vec<String>,
68 uv: u32,
69 next: u32,
70 modseq: u64,
71 msgs: Vec<Msg>,
72 expunged: Vec<(u32, u64)>,
73}
74
75#[derive(Default)]
76struct Server {
77 caps: Vec<String>,
78 folders: BTreeMap<String, Folder>,
79 open: Option<String>,
80 read_only: bool, // opened with EXAMINE, so a flag write, move or expunge is refused
81 loose: bool, // SEARCH answers every UID, as Steel's did (B1)
82 log: Vec<String>,
83 gm_next: u64,
84 answer: Answer, // how the next APPEND is answered, once
85 on_append: Option<fn(&mut Server)>, // a second actor, run once after an APPEND is stored
86 dates: BTreeMap<u32, String>, // x2: INTERNALDATE by UID, else the fixed one
87 meta_for: Option<u32>, // x2: a Meta FETCH answered for this UID instead
88 on_store: Option<fn(&mut Server)>, // x2: a second actor, run once before a STORE
89 cut_store: bool, // the next STORE cut before it reaches the server, once
90 flags_none: bool, // x3: a Flags FETCH answered with nothing
91}
92
93/// How the scripted server answers one APPEND.
94#[derive(Clone, Copy, Debug, Default)]
95enum Answer {
96 #[default]
97 Uid, // OK [APPENDUID ..]
98 NoUid, // OK, without APPENDUID
99 CutBefore, // the connection drops before the server has it: not stored
100 CutAfter, // stored, and the connection drops before the tagged OK
101 Refuse(&'static str), // NO or BAD, or BYE in place of the answer: not stored
102}
103
104fn raw(mid: &str, year: u16) -> Vec<u8> {
105 fmt!("Message-ID: <{}>\r\nDate: 1 Jan {} 09:00:00 +0000\r\nSubject: {}\r\n\r\nbody of {}\r\n",
106 mid, year, mid, mid).into_bytes()
107}
108
109impl Server {
110 fn new(caps: &str) -> Self {
111 let mut s = Self { caps: caps.split_whitespace().map(String::from).collect(), ..Default::default() };
112 // A degraded run: SEARCH answers every UID, as a garbling server may.
113 s.loose = std::env::var("MAIL_FAULT").map_or(false, |v| v == "garble");
114 s.folder("INBOX", "", 100);
115 s
116 }
117
118 /// `SELECT` or `EXAMINE`, as `verb` names; read-write until `examine` says otherwise.
119 fn open_box(&mut self, verb: &str, mb: &str, with: &SelectWith) -> Outcome<MailboxStatus> {
120 self.log.push(fmt!("{} {} {}", verb, mb, match with {
121 SelectWith::Plain => "",
122 SelectWith::CondStore => "CONDSTORE",
123 SelectWith::QResync { .. } => "QRESYNC",
124 }));
125 let modseqs = self.cap("CONDSTORE") || self.cap("QRESYNC");
126 let f = res!(self.folders.get(mb).ok_or_else(|| err!("No mailbox {}.", mb; Missing)));
127 let mut st = MailboxStatus {
128 name: mb.to_string(),
129 exists: f.msgs.len() as u32,
130 uid_validity: f.uv,
131 uid_next: f.next,
132 highest_modseq: if modseqs { Some(f.modseq) } else { None },
133 ..Default::default()
134 };
135 if let SelectWith::QResync { uid_validity, modseq, known } = with {
136 if *uid_validity == f.uv {
137 st.changed = f.msgs.iter().filter(|m| m.modseq > *modseq)
138 .map(|m| Server::fetched(m, FetchWhat::Flags, false)).collect();
139 for (u, ms) in &f.expunged {
140 if *ms > *modseq && known.as_ref().map(|k| k.contains(*u)).unwrap_or(true) {
141 st.vanished.insert(*u);
142 }
143 }
144 }
145 }
146 self.open = Some(mb.to_string());
147 self.read_only = false;
148 Ok(st)
149 }
150
151 fn folder(&mut self, name: &str, attr: &str, uv: u32) {
152 self.folders.insert(name.to_string(), Folder {
153 attrs: attr.split_whitespace().map(String::from).collect(),
154 uv,
155 next: 1,
156 modseq: 1,
157 ..Default::default()
158 });
159 }
160
161 fn deliver(&mut self, mb: &str, mid: &str) -> u32 {
162 self.gm_next += 1;
163 let gm = self.gm_next;
164 let f = self.folders.get_mut(mb).unwrap();
165 f.modseq += 1;
166 let uid = f.next;
167 f.next += 1;
168 f.msgs.push(Msg { uid, flags: Vec::new(), raw: raw(mid, 2025), modseq: f.modseq, gm });
169 uid
170 }
171
172 /// A message with the bytes and flags given, at the next UID.
173 fn put(&mut self, mb: &str, raw: &[u8], flags: &[&str]) -> u32 {
174 let f = self.folders.get_mut(mb).unwrap();
175 f.modseq += 1;
176 let uid = f.next;
177 f.next += 1;
178 let flags = flags.iter().map(|x| x.to_string()).collect();
179 f.msgs.push(Msg { uid, flags, raw: raw.to_vec(), modseq: f.modseq, gm: 0 });
180 uid
181 }
182
183 /// A message put under a UID the folder held before, as a server that breaks RFC 3501 does.
184 fn deliver_at(&mut self, mb: &str, uid: u32, mid: &str) {
185 let f = self.folders.get_mut(mb).unwrap();
186 f.modseq += 1;
187 f.msgs.push(Msg { uid, flags: Vec::new(), raw: raw(mid, 2025), modseq: f.modseq, gm: 0 });
188 }
189
190 fn set_flags(&mut self, mb: &str, uid: u32, flags: &[&str]) {
191 let f = self.folders.get_mut(mb).unwrap();
192 f.modseq += 1;
193 let m = f.msgs.iter_mut().find(|m| m.uid == uid).unwrap();
194 m.flags = flags.iter().map(|s| s.to_string()).collect();
195 m.modseq = f.modseq;
196 }
197
198 fn expunge(&mut self, mb: &str, uid: u32) {
199 let f = self.folders.get_mut(mb).unwrap();
200 f.modseq += 1;
201 f.msgs.retain(|m| m.uid != uid);
202 f.expunged.push((uid, f.modseq));
203 }
204
205 /// The folder is rebuilt under a new UIDVALIDITY with the same messages renumbered.
206 fn renumber(&mut self, mb: &str, uv: u32) {
207 let f = self.folders.get_mut(mb).unwrap();
208 f.uv = uv;
209 f.expunged.clear();
210 for (i, m) in f.msgs.iter_mut().enumerate() {
211 m.uid = 50 + i as u32;
212 }
213 f.next = 50 + f.msgs.len() as u32;
214 }
215
216 fn has(&self, mb: &str, mid: &str) -> bool {
217 let r = raw(mid, 2025);
218 self.folders[mb].msgs.iter().any(|m| m.raw == r)
219 }
220
221 fn cur(&mut self) -> Outcome<&mut Folder> {
222 let o = res!(self.open.clone().ok_or_else(|| err!("No mailbox selected."; Missing)));
223 self.folders.get_mut(&o).ok_or_else(|| err!("No such mailbox {}.", o; Missing))
224 }
225
226 fn cap(&self, c: &str) -> bool {
227 self.caps.iter().any(|x| x == c)
228 }
229
230 fn fetched(m: &Msg, what: FetchWhat, gmail: bool) -> FetchedMessage {
231 let head_end = m.raw.windows(4).position(|w| w == b"\r\n\r\n").unwrap() + 4;
232 let body = match what {
233 FetchWhat::Flags | FetchWhat::Meta | FetchWhat::BodyStructure => Vec::new(),
234 FetchWhat::Headers | FetchWhat::Summary | FetchWhat::Structure
235 => m.raw[..head_end].to_vec(),
236 FetchWhat::Full => m.raw.clone(),
237 FetchWhat::MessageId => {
238 // The field with its folded lines, or nothing, as HEADER.FIELDS answers.
239 let head = String::from_utf8_lossy(&m.raw[..head_end]).to_string();
240 let mut field = String::new();
241 for l in head.split_inclusive("\r\n") {
242 if l.to_ascii_lowercase().starts_with("message-id:")
243 || (!field.is_empty() && l.starts_with([' ', '\t']))
244 {
245 field.push_str(l);
246 } else if !field.is_empty() {
247 break;
248 }
249 }
250 fmt!("{}\r\n", field).into_bytes()
251 }
252 };
253 FetchedMessage {
254 uid: m.uid,
255 flags: m.flags.clone(),
256 internal_date: "01-Jan-2025 09:00:00 +0000".to_string(),
257 size: m.raw.len() as u32,
258 body,
259 modseq: Some(m.modseq),
260 gm_msgid: if gmail { Some(m.gm) } else { None },
261 ..Default::default()
262 }
263 }
264}
265
266impl MailSession for Server {
267 async fn capabilities(&mut self) -> Outcome<Vec<String>> {
268 Ok(self.caps.clone())
269 }
270
271 async fn list(&mut self) -> Outcome<Vec<MailboxInfo>> {
272 Ok(self.folders.iter().map(|(n, f)| MailboxInfo {
273 name: n.clone(), delimiter: Some('/'), attrs: f.attrs.clone(),
274 }).collect())
275 }
276
277 async fn create(&mut self, mb: &str) -> Outcome<()> {
278 self.log.push(fmt!("CREATE {}", mb));
279 // As a server answers NO [ALREADYEXISTS].
280 if self.folders.contains_key(mb) {
281 return Err(err!("NO [ALREADYEXISTS] {}", mb; Invalid, Input));
282 }
283 self.folder(mb, "", 900);
284 Ok(())
285 }
286
287 async fn select(&mut self, mb: &str, with: &SelectWith) -> Outcome<MailboxStatus> {
288 self.open_box("SELECT", mb, with)
289 }
290
291 async fn examine(&mut self, mb: &str, with: &SelectWith) -> Outcome<MailboxStatus> {
292 let st = res!(self.open_box("EXAMINE", mb, with));
293 self.read_only = true;
294 Ok(st)
295 }
296
297 async fn uid_fetch(&mut self, uids: &UidSet, what: FetchWhat) -> Outcome<Vec<FetchedMessage>> {
298 self.log.push(fmt!("UID FETCH {} {:?}", uids, what));
299 let gmail = self.cap("X-GM-EXT-1");
300 let f = res!(self.cur());
301 let mut out: Vec<FetchedMessage> = f.msgs.iter().filter(|m| uids.contains(m.uid))
302 .map(|m| Server::fetched(m, what, gmail)).collect();
303 // `n:*` past the last UID answers with the last message (RFC 3501 6.4.8).
304 if out.is_empty() && uids.last() == Some(u32::MAX) {
305 if let Some(m) = f.msgs.last() {
306 out.push(Server::fetched(m, what, gmail));
307 }
308 }
309 if self.flags_none && what == FetchWhat::Flags {
310 out.clear();
311 }
312 for m in out.iter_mut() {
313 if let Some(d) = self.dates.get(&m.uid) {
314 m.internal_date = d.clone();
315 }
316 if let (FetchWhat::Meta, Some(o)) = (what, self.meta_for) {
317 m.uid = o;
318 }
319 }
320 Ok(out)
321 }
322
323 async fn uid_fetch_section(&mut self, uid: u32, section: &str, max: u32)
324 -> Outcome<Option<FetchedMessage>>
325 {
326 self.log.push(fmt!("UID FETCH {} BODY.PEEK[{}]<0.{}>", uid, section, max));
327 let f = res!(self.cur());
328 Ok(f.msgs.iter().find(|m| m.uid == uid).map(|m| {
329 let mut fm = Server::fetched(m, FetchWhat::Full, false);
330 fm.body.truncate(max as usize);
331 if let Some((hu, cut)) = X4_SECTION.with(|x| x.get()) { if hu == fm.uid { if cut { fm.body.pop(); } else if let Some(b) = fm.body.last_mut() { *b ^= 0x20; } } }
332 fm
333 }))
334 }
335
336 fn read_bytes(&self) -> u64 {
337 0 // no wire; nothing here searches
338 }
339 async fn count(&mut self, mailbox: &str) -> Outcome<u32> {
340 self.log.push(fmt!("STATUS {} (MESSAGES)", mailbox));
341 Ok(res!(self.folders.get(mailbox)
342 .ok_or_else(|| err!("No mailbox {}.", mailbox; Missing))).msgs.len() as u32)
343 }
344
345 async fn uid_fetch_changed(&mut self, uids: &UidSet, what: FetchWhat, modseq: u64)
346 -> Outcome<FetchChanged>
347 {
348 self.log.push(fmt!("UID FETCH {} {:?} CHANGEDSINCE {}", uids, what, modseq));
349 let f = res!(self.cur());
350 Ok(FetchChanged {
351 messages: f.msgs.iter().filter(|m| uids.contains(m.uid) && m.modseq > modseq)
352 .map(|m| Server::fetched(m, what, false)).collect(),
353 vanished: UidSet::new(),
354 })
355 }
356
357 async fn uid_search(&mut self, criteria: &str) -> Outcome<Vec<u32>> {
358 self.log.push(fmt!("UID SEARCH {}", criteria));
359 let loose = self.loose;
360 let f = res!(self.cur());
361 let all: Vec<u32> = f.msgs.iter().map(|m| m.uid).collect();
362 if criteria == "ALL" || loose {
363 return Ok(all);
364 }
365 if let Some(set) = criteria.strip_prefix("UID ") {
366 let set = res!(UidSet::parse(set));
367 return Ok(all.into_iter().filter(|u| set.contains(*u)).collect());
368 }
369 if let Some(mid) = criteria.strip_prefix("HEADER Message-ID ") {
370 let mid = mid.trim_matches('"');
371 return Ok(f.msgs.iter()
372 .filter(|m| String::from_utf8_lossy(&m.raw).contains(mid))
373 .map(|m| m.uid).collect());
374 }
375 Err(err!("Unscripted search {}.", criteria; NoImpl))
376 }
377
378 async fn uid_store_flags(&mut self, uids: &UidSet, add: &[&str], remove: &[&str]) -> Outcome<()> {
379 if self.read_only {
380 return Err(err!("NO The mailbox is read-only: UID STORE {}.", uids; Invalid, Input));
381 }
382 if let Some(h) = self.on_store.take() {
383 h(self);
384 }
385 if std::mem::take(&mut self.cut_store) {
386 return Err(err!("The connection dropped before UID STORE {}.", uids; IO, Network));
387 }
388 self.log.push(fmt!("UID STORE {} +{:?} -{:?}", uids, add, remove));
389 let f = res!(self.cur());
390 f.modseq += 1;
391 let ms = f.modseq;
392 for m in f.msgs.iter_mut().filter(|m| uids.contains(m.uid)) {
393 m.flags.retain(|x| !remove.contains(&x.as_str()));
394 for a in add {
395 if !m.flags.iter().any(|x| x == a) {
396 m.flags.push(a.to_string());
397 }
398 }
399 m.modseq = ms;
400 }
401 Ok(())
402 }
403
404 async fn uid_copy(&mut self, uids: &UidSet, to: &str) -> Outcome<Option<CopyUid>> {
405 self.log.push(fmt!("UID COPY {} {}", uids, to));
406 let src: Vec<Msg> = res!(self.cur()).msgs.iter().filter(|m| uids.contains(m.uid)).cloned().collect();
407 let d = res!(self.folders.get_mut(to).ok_or_else(|| err!("No mailbox {}.", to; Missing)));
408 for mut m in src {
409 m.uid = d.next;
410 d.next += 1;
411 d.modseq += 1;
412 m.modseq = d.modseq;
413 d.msgs.push(m);
414 }
415 Ok(None)
416 }
417
418 async fn uid_move(&mut self, uids: &UidSet, to: &str) -> Outcome<Option<CopyUid>> {
419 if !self.cap("MOVE") {
420 return Err(err!("MOVE not offered."; NoImpl));
421 }
422 let c = res!(self.uid_copy(uids, to).await);
423 self.log.push(fmt!("(the copy was a MOVE)"));
424 let o = self.open.clone().unwrap();
425 for u in uids.iter() {
426 self.expunge(&o, u);
427 }
428 Ok(c)
429 }
430
431 async fn uid_expunge(&mut self, uids: &UidSet) -> Outcome<()> {
432 self.log.push(fmt!("UID EXPUNGE {}", uids));
433 let o = self.open.clone().unwrap();
434 let del: Vec<u32> = self.folders[&o].msgs.iter()
435 .filter(|m| uids.contains(m.uid) && m.flags.iter().any(|f| f == "\\Deleted"))
436 .map(|m| m.uid).collect();
437 for u in del {
438 self.expunge(&o, u);
439 }
440 Ok(())
441 }
442
443 async fn append(&mut self, mb: &str, flags: &[&str], raw: &[u8]) -> Outcome<Option<AppendUid>> {
444 self.log.push(fmt!("APPEND {} {:?}", mb, flags));
445 let answer = std::mem::take(&mut self.answer);
446 match answer {
447 Answer::CutBefore => return Err(err!("The connection dropped before APPEND reached \
448 the server."; IO, Network)),
449 Answer::Refuse(w) => return Err(err!("{}", w; Invalid, Input)),
450 _ => {},
451 }
452 let uid = self.put(mb, raw, flags);
453 let au = AppendUid { uid_validity: self.folders[mb].uv, uid };
454 if let Some(hook) = self.on_append.take() {
455 hook(self);
456 }
457 match answer {
458 Answer::CutAfter => Err(err!("The connection dropped before APPEND's tagged OK."; IO, Network)),
459 Answer::NoUid => Ok(None),
460 _ => Ok(Some(au)),
461 }
462 }
463}
464
465
466// ┌───────────────────────────────────────────────────────────────────────────┐
467// │ THE DEVICE'S STORE │
468// └───────────────────────────────────────────────────────────────────────────┘
469
470#[derive(Clone, Debug, Default, PartialEq)]
471struct Gen {
472 uv: u32,
473 msgs: BTreeMap<String, Vec<u8>>, // Maildir name to bytes
474}
475
476#[derive(Clone, Debug, Default, PartialEq)]
477struct Held {
478 gen: Option<Gen>,
479 aside: Option<Gen>,
480 cursor: Option<Cursor>,
481}
482
483#[derive(Default)]
484struct Store {
485 folders: BTreeMap<String, Held>,
486 fail_put: bool,
487}
488
489impl Store {
490 fn names(&self, mb: &str) -> Vec<String> {
491 self.folders.get(mb).and_then(|h| h.gen.as_ref())
492 .map(|g| g.msgs.keys().cloned().collect()).unwrap_or_default()
493 }
494
495 fn find(&self, mb: &str, key: MsgKey) -> Option<String> {
496 self.names(mb).into_iter().find(|n| parse_maildir_name(n).map(|p| p.0) == Some(key))
497 }
498
499 fn gen(&mut self, mb: &str) -> Outcome<&mut Gen> {
500 self.folders.get_mut(mb).and_then(|h| h.gen.as_mut())
501 .ok_or_else(|| err!("{} has no generation.", mb; Missing))
502 }
503
504 /// The held set and cursor to send next, as a device would.
505 fn snapshot(&self, mb: &str) -> Snapshot {
506 let held: Vec<u32> = self.names(mb).iter()
507 .filter_map(|n| parse_maildir_name(n)).map(|p| p.0.uid).collect();
508 let held = UidSet::from(&held);
509 Snapshot {
510 mailbox: mb.to_string(),
511 cursor: self.folders.get(mb).and_then(|h| h.cursor.clone()).unwrap_or_default(),
512 window: UidSet::new(),
513 held,
514 }
515 }
516
517 fn flags_of(&self, mb: &str, uid: u32) -> Vec<String> {
518 let uv = self.folders[mb].gen.as_ref().unwrap().uv;
519 let n = self.find(mb, MsgKey { uid_validity: uv, uid }).unwrap();
520 parse_maildir_name(&n).unwrap().1
521 }
522}
523
524impl SyncStore for Store {
525 fn generation(&self, mb: &str) -> Outcome<Option<u32>> {
526 Ok(self.folders.get(mb).and_then(|h| h.gen.as_ref()).map(|g| g.uv))
527 }
528
529 fn begin_generation(&mut self, mb: &str, uv: u32) -> Outcome<()> {
530 let h = self.folders.entry(mb.to_string()).or_default();
531 h.aside = h.gen.take();
532 h.gen = Some(Gen { uv, ..Default::default() });
533 Ok(())
534 }
535
536 fn end_generation(&mut self, mb: &str) -> Outcome<()> {
537 if let Some(h) = self.folders.get_mut(mb) {
538 h.aside = None;
539 }
540 Ok(())
541 }
542
543 fn flags(&self, mb: &str, key: MsgKey) -> Outcome<Option<Vec<String>>> {
544 Ok(self.find(mb, key).and_then(|n| parse_maildir_name(&n)).map(|p| p.1))
545 }
546
547 fn put(&mut self, mb: &str, key: MsgKey, flags: &[String], raw: &[u8], _whole: bool)
548 -> Outcome<bool>
549 {
550 if self.fail_put {
551 return Err(err!("The disk is full."; IO));
552 }
553 if self.find(mb, key).is_some() {
554 return Ok(false);
555 }
556 res!(self.gen(mb)).msgs.insert(maildir_name(key, flags), raw.to_vec());
557 Ok(true)
558 }
559
560 fn change_flags(&mut self, mb: &str, key: MsgKey, add: &[String], remove: &[String])
561 -> Outcome<()>
562 {
563 let old = res!(self.find(mb, key).ok_or_else(|| err!("Not held."; Missing)));
564 let mut f = parse_maildir_name(&old).unwrap().1;
565 f.retain(|x| !remove.contains(x));
566 f.extend(add.iter().cloned());
567 let g = res!(self.gen(mb));
568 let bytes = g.msgs.remove(&old).unwrap();
569 g.msgs.insert(maildir_name(key, &f), bytes);
570 Ok(())
571 }
572
573 fn remove(&mut self, mb: &str, key: MsgKey) -> Outcome<bool> {
574 match self.find(mb, key) {
575 Some(n) => { res!(self.gen(mb)).msgs.remove(&n); Ok(true) }
576 None => Ok(false),
577 }
578 }
579
580 fn cursor(&self, mb: &str) -> Outcome<Option<Cursor>> {
581 Ok(self.folders.get(mb).and_then(|h| h.cursor.clone()))
582 }
583
584 fn set_cursor(&mut self, mb: &str, c: &Cursor) -> Outcome<()> {
585 self.folders.entry(mb.to_string()).or_default().cursor = Some(c.clone());
586 Ok(())
587 }
588}
589
590/// One sync and its apply, as the client drives it.
591async fn round(s: &mut Server, st: &mut Store, budget: &Budget, pending: &[Entry]) -> Outcome<Delta> {
592 let caps = Caps::from_list(&res!(s.capabilities().await));
593 let d = res!(sync_folder(s, &caps, &st.snapshot("INBOX"), budget).await);
594 res!(apply(st, &d, pending));
595 Ok(d)
596}
597
598const QRESYNC: &str = "IMAP4rev1 CONDSTORE QRESYNC MOVE UIDPLUS SPECIAL-USE";
599const CONDSTORE: &str = "IMAP4rev1 CONDSTORE MOVE UIDPLUS SPECIAL-USE X-GM-EXT-1";
600const PLAIN: &str = "IMAP4rev1 MOVE UIDPLUS SPECIAL-USE";
601
602
603// ┌───────────────────────────────────────────────────────────────────────────┐
604// │ TIERS, AND NO-LOSS │
605// └───────────────────────────────────────────────────────────────────────────┘
606
607/// Expunge and flag change on the server, then the tier's delta; returns the server's log of the
608/// second sync.
609async fn expunge_and_flag(caps: &str) -> Outcome<(Delta, Vec<String>, Store)> {
610 let mut s = Server::new(caps);
611 for i in 1..=4 {
612 s.deliver("INBOX", &fmt!("m{}@x", i));
613 }
614 let mut st = Store::default();
615 let b = Budget::default();
616 let first = res!(round(&mut s, &mut st, &b, &[]).await);
617 req!(4, first.new.len());
618 req!(4, st.names("INBOX").len());
619 s.expunge("INBOX", 2);
620 s.set_flags("INBOX", 3, &["\\Seen"]);
621 s.log.clear();
622 let d = res!(round(&mut s, &mut st, &b, &[]).await);
623 Ok((d, s.log, st))
624}
625
626#[tokio::test]
627async fn test_qresync_tier_reports_vanished_and_flags_from_select_00() -> Outcome<()> {
628 let (d, log, st) = res!(expunge_and_flag(QRESYNC).await);
629 req!(Some(Tier::QResync), d.tier);
630 req!(UidSet::from([2]), d.vanished);
631 req!(true, d.flags.iter().any(|f| f.uid == 3 && f.flags == vec!["\\Seen".to_string()]));
632 req!(true, log[0].contains("QRESYNC"), "{:?}", log);
633 req!(false, log.iter().any(|l| l.contains("SEARCH")), "{:?}", log);
634 req!(3, st.names("INBOX").len());
635 req!(vec!["\\Seen".to_string()], st.flags_of("INBOX", 3));
636 Ok(())
637}
638
639#[tokio::test]
640async fn test_condstore_tier_uses_changedsince_and_search_uid_00() -> Outcome<()> {
641 let (d, log, st) = res!(expunge_and_flag(CONDSTORE).await);
642 req!(Some(Tier::CondStore), d.tier);
643 req!(UidSet::from([2]), d.vanished);
644 req!(1, d.flags.len());
645 req!(true, log.iter().any(|l| l.contains("CHANGEDSINCE")), "{:?}", log);
646 req!(true, log.iter().any(|l| l.starts_with("UID SEARCH UID 1:4")), "{:?}", log);
647 req!(3, st.names("INBOX").len());
648 Ok(())
649}
650
651#[tokio::test]
652async fn test_full_tier_reconciles_by_search_all_00() -> Outcome<()> {
653 let (d, log, st) = res!(expunge_and_flag(PLAIN).await);
654 req!(Some(Tier::Full), d.tier);
655 req!(UidSet::from([2]), d.vanished);
656 req!(true, log.iter().any(|l| l == "UID SEARCH ALL"), "{:?}", log);
657 req!(3, st.names("INBOX").len());
658 Ok(())
659}
660
661/// Tier 3 reads flags inside the window each poll, and over every held message each Nth, so an
662/// old message read elsewhere does not stay unread here.
663#[tokio::test]
664async fn test_full_tier_sweeps_every_held_flag_each_nth_poll_00() -> Outcome<()> {
665 let mut s = Server::new(PLAIN);
666 for i in 1..=5 {
667 s.deliver("INBOX", &fmt!("m{}@x", i));
668 }
669 let mut st = Store::default();
670 let b = Budget { sweep_every: 3, ..Budget::default() };
671 res!(round(&mut s, &mut st, &b, &[]).await); // poll 0: fresh, nothing held yet
672 s.set_flags("INBOX", 1, &["\\Seen"]); // old, outside the window
673 let mut seen_at = None;
674 for poll in 1..=4 {
675 let caps = Caps::from_list(&s.caps);
676 let mut snap = st.snapshot("INBOX");
677 snap.window = UidSet::from([5]);
678 let d = res!(sync_folder(&mut s, &caps, &snap, &b).await);
679 res!(apply(&mut st, &d, &[]));
680 if seen_at.is_none() && st.flags_of("INBOX", 1) == vec!["\\Seen".to_string()] {
681 seen_at = Some(poll);
682 }
683 }
684 // The fresh sync was the cursor's poll 0; polls 1 and 2 read the window only; poll 3 sweeps.
685 req!(Some(3), seen_at);
686 Ok(())
687}
688
689/// A big arrival is fetched newest first in bounded pieces, and none is skipped.
690#[tokio::test]
691async fn test_new_messages_bounded_newest_first_none_lost_00() -> Outcome<()> {
692 let mut s = Server::new(QRESYNC);
693 for i in 1..=7 {
694 s.deliver("INBOX", &fmt!("m{}@x", i));
695 }
696 let mut st = Store::default();
697 let b = Budget { max_count: 3, ..Budget::default() };
698 let d = res!(round(&mut s, &mut st, &b, &[]).await);
699 req!(vec![7, 6, 5], d.new.iter().map(|m| m.uid).collect::<Vec<_>>());
700 req!(true, d.more);
701 s.expunge("INBOX", 3); // gone before it was fetched
702 s.deliver("INBOX", "m8@x");
703 let d = res!(round(&mut s, &mut st, &b, &[]).await);
704 req!(vec![8, 4, 2], d.new.iter().map(|m| m.uid).collect::<Vec<_>>());
705 let d = res!(round(&mut s, &mut st, &b, &[]).await);
706 req!(vec![1], d.new.iter().map(|m| m.uid).collect::<Vec<_>>());
707 req!(false, d.more);
708 req!(7, st.names("INBOX").len());
709 let d = res!(round(&mut s, &mut st, &b, &[]).await);
710 req!(0, d.new.len()); // `9:*` answered with UID 8: dropped
711 Ok(())
712}
713
714/// Only mail that came after a folder became known is an arrival: what a capped first sync left
715/// behind is fetched later without being one, and so is a rebuild's backlog; a message delivered
716/// meanwhile is one, and is fetched beside that backlog.
717#[tokio::test]
718async fn test_only_mail_after_the_first_sync_is_an_arrival_00() -> Outcome<()> {
719 for caps in [QRESYNC, CONDSTORE, PLAIN] {
720 let mut s = Server::new(caps);
721 for i in 1..=7 {
722 s.deliver("INBOX", &fmt!("m{}@x", i));
723 }
724 let mut st = Store::default();
725 let b = Budget { max_count: 3, ..Budget::default() };
726 let arrived = |d: &Delta| d.new.iter().filter(|m| m.arrival).map(|m| m.uid).collect::<Vec<_>>();
727 let d = res!(round(&mut s, &mut st, &b, &[]).await);
728 req!(Vec::<u32>::new(), arrived(&d), "{} first", caps);
729 req!(7, d.cursor.floor, "{}", caps);
730 s.deliver("INBOX", "m8@x");
731 let d = res!(round(&mut s, &mut st, &b, &[]).await);
732 req!(vec![8, 4, 3], d.new.iter().map(|m| m.uid).collect::<Vec<_>>(), "{}", caps);
733 req!(vec![8], arrived(&d), "{} backlog beside a delivery", caps);
734 let d = res!(round(&mut s, &mut st, &b, &[]).await);
735 req!(vec![2, 1], d.new.iter().map(|m| m.uid).collect::<Vec<_>>(), "{}", caps);
736 req!(Vec::<u32>::new(), arrived(&d), "{} completion", caps);
737 req!(false, d.more);
738 s.deliver("INBOX", "m9@x");
739 let d = res!(round(&mut s, &mut st, &b, &[]).await);
740 req!(vec![9], arrived(&d), "{} after", caps);
741 // A rebuild brings the folder back under new UIDs, above the old floor: none arrives.
742 s.renumber("INBOX", 777);
743 loop {
744 let d = res!(round(&mut s, &mut st, &b, &[]).await);
745 req!(Vec::<u32>::new(), arrived(&d), "{} rebuild", caps);
746 if !d.more { break; }
747 }
748 s.deliver("INBOX", "m10@x");
749 let d = res!(round(&mut s, &mut st, &b, &[]).await);
750 req!(1, arrived(&d).len(), "{} after the rebuild", caps);
751 }
752 Ok(())
753}
754
755/// Header fetches count against `max_bytes` as bodies do, so a request's bytes are bounded by
756/// the budget and not by `max_count` times the header size; nothing is skipped meanwhile.
757#[tokio::test]
758async fn test_header_bytes_count_against_the_byte_budget_00() -> Outcome<()> {
759 for bodies in [false, true] {
760 let mut s = Server::new(QRESYNC);
761 for i in 1..=12 {
762 s.deliver("INBOX", &fmt!("m{}@x", i));
763 }
764 let mut st = Store::default();
765 let b = Budget { max_count: 200, max_bytes: 250, bodies, ..Budget::default() };
766 let mut rounds = 0;
767 loop {
768 let d = res!(round(&mut s, &mut st, &b, &[]).await);
769 let bytes: u64 = d.new.iter().map(|m| m.raw.len() as u64).sum();
770 req!(true, bytes <= b.max_bytes, "round {} carried {} bytes", rounds, bytes);
771 req!(true, !d.new.is_empty() || !d.more);
772 rounds += 1;
773 if !d.more || rounds > 20 {
774 break;
775 }
776 }
777 req!(true, rounds > 1);
778 req!(12, st.names("INBOX").len());
779 }
780 // A single header over the whole budget still moves: one message per request.
781 let mut s = Server::new(QRESYNC);
782 for i in 1..=3 {
783 s.deliver("INBOX", &fmt!("m{}@x", i));
784 }
785 let mut st = Store::default();
786 let b = Budget { max_count: 200, max_bytes: 10, ..Budget::default() };
787 for want in [vec![3], vec![2], vec![1]] {
788 let d = res!(round(&mut s, &mut st, &b, &[]).await);
789 req!(want, d.new.iter().map(|m| m.uid).collect::<Vec<_>>());
790 }
791 req!(3, st.names("INBOX").len());
792 Ok(())
793}
794
795
796// ┌───────────────────────────────────────────────────────────────────────────┐
797// │ RESET, REPLAY, THE CURSOR AND THE JOURNAL │
798// └───────────────────────────────────────────────────────────────────────────┘
799
800#[tokio::test]
801async fn test_uidvalidity_reset_one_generation_no_duplicates_00() -> Outcome<()> {
802 for caps in [QRESYNC, CONDSTORE, PLAIN] {
803 let mut s = Server::new(caps);
804 for i in 1..=5 {
805 s.deliver("INBOX", &fmt!("m{}@x", i));
806 }
807 let mut st = Store::default();
808 let b = Budget { max_count: 2, ..Budget::default() };
809 while res!(round(&mut s, &mut st, &b, &[]).await).more {}
810 s.renumber("INBOX", 777);
811 let d = res!(round(&mut s, &mut st, &b, &[]).await);
812 req!(Some(oxedyne_fe2o3_mail::sync::Reset { old: 100, new: 777 }), d.reset, "{}", caps);
813 // The old generation is set aside, not mixed in, until the rebuild completes.
814 req!(true, st.folders["INBOX"].aside.is_some());
815 req!(2, st.names("INBOX").len());
816 while res!(round(&mut s, &mut st, &b, &[]).await).more {}
817 req!(true, st.folders["INBOX"].aside.is_none());
818 let names = st.names("INBOX");
819 req!(5, names.len(), "{}", caps);
820 req!(true, names.iter().all(|n| n.starts_with("777.")), "{:?}", names);
821 }
822 Ok(())
823}
824
825#[tokio::test]
826async fn test_replayed_apply_is_a_no_op_00() -> Outcome<()> {
827 let mut s = Server::new(QRESYNC);
828 for i in 1..=3 {
829 s.deliver("INBOX", &fmt!("m{}@x", i));
830 }
831 let mut st = Store::default();
832 let b = Budget::default();
833 res!(round(&mut s, &mut st, &b, &[]).await);
834 s.expunge("INBOX", 1);
835 s.set_flags("INBOX", 2, &["\\Flagged"]);
836 s.deliver("INBOX", "m4@x");
837 let caps = Caps::from_list(&s.caps);
838 let d = res!(sync_folder(&mut s, &caps, &st.snapshot("INBOX"), &b).await);
839 let once = res!(apply(&mut st, &d, &[]));
840 req!((1, 1, 1), (once.added, once.changed, once.removed));
841 let after = st.folders.clone();
842 let twice = res!(apply(&mut st, &d, &[]));
843 req!((0, 0, 0), (twice.added, twice.changed, twice.removed));
844 req!(true, after == st.folders);
845 // A reset delta replayed does not set aside the rebuilt generation.
846 s.renumber("INBOX", 555);
847 let d = res!(sync_folder(&mut s, &caps, &st.snapshot("INBOX"), &b).await);
848 res!(apply(&mut st, &d, &[]));
849 let after = st.folders.clone();
850 let again = res!(apply(&mut st, &d, &[]));
851 req!(0, again.added);
852 req!(true, after == st.folders);
853 Ok(())
854}
855
856/// The cursor is stored only once the writes land: a failed apply leaves it where it was, so the
857/// next sync asks for the same messages again.
858#[tokio::test]
859async fn test_cursor_not_advanced_when_apply_fails_00() -> Outcome<()> {
860 let mut s = Server::new(QRESYNC);
861 s.deliver("INBOX", "m1@x");
862 let mut st = Store::default();
863 let b = Budget::default();
864 res!(round(&mut s, &mut st, &b, &[]).await);
865 let before = st.folders["INBOX"].cursor.clone();
866 s.deliver("INBOX", "m2@x");
867 st.fail_put = true;
868 req!(true, round(&mut s, &mut st, &b, &[]).await.is_err());
869 req!(before, st.folders["INBOX"].cursor.clone());
870 st.fail_put = false;
871 let d = res!(round(&mut s, &mut st, &b, &[]).await);
872 req!(vec![2], d.new.iter().map(|m| m.uid).collect::<Vec<_>>());
873 Ok(())
874}
875
876/// A press he has just made (`+\Seen`, a move away) is not undone by a delta read before the
877/// server had it.
878#[tokio::test]
879async fn test_delta_never_undoes_a_pending_change_00() -> Outcome<()> {
880 let mut s = Server::new(CONDSTORE);
881 for i in 1..=3 {
882 s.deliver("INBOX", &fmt!("m{}@x", i));
883 }
884 let mut st = Store::default();
885 let b = Budget::default();
886 res!(round(&mut s, &mut st, &b, &[]).await);
887 let uv = 100;
888 // Optimistically read here; meanwhile his phone flagged it and cleared nothing.
889 let seen = Entry {
890 id: 1, mailbox: "INBOX".into(), uid_validity: uv, uid: 1,
891 action: Action::Flags { add: vec!["\\Seen".into()], remove: vec![] },
892 ..Default::default()
893 };
894 let key = MsgKey { uid_validity: uv, uid: 1 };
895 res!(st.change_flags("INBOX", key, &["\\Seen".into()], &[]));
896 s.set_flags("INBOX", 1, &["\\Flagged"]);
897 // Optimistically moved away; the server still shows it here, with a flag change.
898 let gone = Entry {
899 id: 2, mailbox: "INBOX".into(), uid_validity: uv, uid: 2,
900 action: Action::Trash, ..Default::default()
901 };
902 res!(st.remove("INBOX", MsgKey { uid_validity: uv, uid: 2 }));
903 s.set_flags("INBOX", 2, &["\\Answered"]);
904 // The device still names UID 2 as held, so the server's change to it reaches the delta.
905 let caps = Caps::from_list(&s.caps);
906 let mut snap = st.snapshot("INBOX");
907 snap.held.insert(2);
908 let d = res!(sync_folder(&mut s, &caps, &snap, &b).await);
909 req!(2, d.flags.len());
910 res!(apply(&mut st, &d, &[seen.clone(), gone.clone()]));
911 let mut f = st.flags_of("INBOX", 1);
912 f.sort();
913 req!(vec!["\\Flagged".to_string(), "\\Seen".to_string()], f);
914 req!(true, res!(st.flags("INBOX", MsgKey { uid_validity: uv, uid: 2 })).is_none());
915 Ok(())
916}
917
918
919// ┌───────────────────────────────────────────────────────────────────────────┐
920// │ ACTIONS AND THEIR OUTCOMES │
921// └───────────────────────────────────────────────────────────────────────────┘
922
923fn account(caps: &str) -> Server {
924 let mut s = Server::new(caps);
925 s.folder("Sent", "\\Sent", 200);
926 s.folder("Trash", "\\Trash", 300);
927 s.folder("Junk", "\\Junk", 400);
928 s.folder("Elsewhere", "", 500);
929 s
930}
931
932async fn roles(s: &mut Server) -> Outcome<(Caps, Roles)> {
933 let caps = Caps::from_list(&res!(s.capabilities().await));
934 let mut roles = Roles::from_list(&res!(s.list().await));
935 roles.archive = Some("Archive".into()); // the caller's configured archive
936 Ok((caps, roles))
937}
938
939fn entry(uid: u32, mid: &str, action: Action) -> Entry {
940 Entry {
941 id: uid as u64, mailbox: "INBOX".into(), uid_validity: 100, uid,
942 message_id: fmt!("<{}>", mid), size: raw(mid, 2025).len() as u32, year: Some(2025),
943 internal_date: "01-Jan-2025 09:00:00 +0000".into(), action,
944 }
945}
946
947#[tokio::test]
948async fn test_flag_change_on_an_expunged_uid_is_gone_00() -> Outcome<()> {
949 let mut s = account(PLAIN);
950 let u = s.deliver("INBOX", "a@x");
951 s.expunge("INBOX", u);
952 let (caps, r) = res!(roles(&mut s).await);
953 let e = entry(u, "a@x", Action::Flags { add: vec!["\\Seen".into()], remove: vec![] });
954 req!(ActOutcome::Gone, res!(act(&mut s, &caps, &r, Provider::Steel, &e).await));
955 req!(false, s.log.iter().any(|l| l.starts_with("UID STORE")));
956 Ok(())
957}
958
959#[tokio::test]
960async fn test_flags_are_sent_as_deltas_00() -> Outcome<()> {
961 let mut s = account(PLAIN);
962 let u = s.deliver("INBOX", "a@x");
963 s.set_flags("INBOX", u, &["\\Answered", "\\Flagged"]);
964 let (caps, r) = res!(roles(&mut s).await);
965 let e = entry(u, "a@x", Action::Flags { add: vec!["\\Seen".into()], remove: vec!["\\Flagged".into()] });
966 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &e).await));
967 let mut f = s.folders["INBOX"].msgs[0].flags.clone();
968 f.sort();
969 req!(vec!["\\Answered".to_string(), "\\Seen".to_string()], f);
970 Ok(())
971}
972
973/// A move whose source is gone: done where the target holds it, superseded where another folder
974/// does, lost where none does.
975#[tokio::test]
976async fn test_move_of_a_gone_source_is_done_superseded_or_lost_00() -> Outcome<()> {
977 let mut s = account(QRESYNC);
978 let a = s.deliver("INBOX", "a@x");
979 let b = s.deliver("INBOX", "b@x");
980 let c = s.deliver("INBOX", "c@x");
981 s.deliver("Trash", "a@x");
982 s.deliver("Elsewhere", "b@x");
983 for u in [a, b, c] {
984 s.expunge("INBOX", u);
985 }
986 let (caps, r) = res!(roles(&mut s).await);
987 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &entry(a, "a@x", Action::Trash)).await));
988 req!(ActOutcome::Superseded("Elsewhere".into()),
989 res!(act(&mut s, &caps, &r, Provider::Steel, &entry(b, "b@x", Action::Trash)).await));
990 req!(ActOutcome::Lost, res!(act(&mut s, &caps, &r, Provider::Steel, &entry(c, "c@x", Action::Trash)).await));
991 Ok(())
992}
993
994/// A loose server's SEARCH names every message; only the FETCH of the Message-ID field decides.
995#[tokio::test]
996async fn test_loose_search_match_is_refused_by_the_confirming_fetch_00() -> Outcome<()> {
997 let mut s = account(PLAIN);
998 s.deliver("INBOX", "other@x");
999 let want = s.deliver("INBOX", "want@x");
1000 s.deliver("INBOX", "want@x.evil");
1001 s.loose = true;
1002 res!(s.select("INBOX", &SelectWith::Plain).await);
1003 let found = res!(find_message_id(&mut s, "<want@x>").await);
1004 req!(vec![want], found.iter().map(|p| p.0).collect::<Vec<_>>());
1005 req!(0, res!(find_message_id(&mut s, "absent@x").await).len());
1006 // And a Sent filing on a loose server still appends when the copy is truly absent.
1007 let (_, r) = res!(roles(&mut s).await);
1008 s.deliver("Sent", "earlier@x");
1009 let filed = res!(file_sent(&mut s, &r, Provider::Steel, "<new@x>", &raw("new@x", 2025)).await);
1010 req!(true, matches!(filed, Filed::Appended(Some(_))), "{:?}", filed);
1011 // A move whose source is gone is not marked done on a loose match in the target.
1012 let gone = s.deliver("INBOX", "moved@x");
1013 s.expunge("INBOX", gone);
1014 let (caps, r) = res!(roles(&mut s).await);
1015 req!(ActOutcome::Lost, res!(act(&mut s, &caps, &r, Provider::Steel, &entry(gone, "moved@x", Action::Trash)).await));
1016 Ok(())
1017}
1018
1019/// After a UIDVALIDITY change an entry is re-found by Message-ID and size, and acted on only when
1020/// exactly one message matches.
1021#[tokio::test]
1022async fn test_renumbered_entry_acts_only_on_a_unique_match_00() -> Outcome<()> {
1023 let mut s = account(PLAIN);
1024 let a = s.deliver("INBOX", "a@x");
1025 let d1 = s.deliver("INBOX", "dup@x");
1026 s.deliver("INBOX", "dup@x");
1027 s.renumber("INBOX", 101);
1028 let (caps, r) = res!(roles(&mut s).await);
1029 let e = entry(a, "a@x", Action::Flags { add: vec!["\\Seen".into()], remove: vec![] });
1030 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &e).await));
1031 req!(vec!["\\Seen".to_string()], s.folders["INBOX"].msgs[0].flags.clone());
1032 let e = entry(d1, "dup@x", Action::Trash);
1033 req!(true, matches!(res!(act(&mut s, &caps, &r, Provider::Steel, &e).await), ActOutcome::Stuck(_)));
1034 let e = entry(9, "none@x", Action::Trash);
1035 req!(true, matches!(res!(act(&mut s, &caps, &r, Provider::Steel, &e).await), ActOutcome::Stuck(_)));
1036 req!(0, s.folders["Trash"].msgs.len());
1037 Ok(())
1038}
1039
1040#[tokio::test]
1041async fn test_no_move_and_no_uidplus_refuses_rather_than_plain_expunge_00() -> Outcome<()> {
1042 let mut s = account("IMAP4rev1 SPECIAL-USE");
1043 let u = s.deliver("INBOX", "a@x");
1044 let (caps, r) = res!(roles(&mut s).await);
1045 req!(true, matches!(res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Trash)).await),
1046 ActOutcome::Stuck(_)));
1047 req!(true, matches!(res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Expunge)).await),
1048 ActOutcome::Stuck(_)));
1049 req!(false, s.log.iter().any(|l| l.contains("EXPUNGE") || l.contains("COPY")), "{:?}", s.log);
1050 req!(1, s.folders["INBOX"].msgs.len());
1051 Ok(())
1052}
1053
1054#[tokio::test]
1055async fn test_copy_store_uid_expunge_without_move_00() -> Outcome<()> {
1056 let mut s = account("IMAP4rev1 UIDPLUS SPECIAL-USE");
1057 let u = s.deliver("INBOX", "a@x");
1058 let (caps, r) = res!(roles(&mut s).await);
1059 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Junk)).await));
1060 req!(true, s.has("Junk", "a@x"));
1061 req!(0, s.folders["INBOX"].msgs.len());
1062 req!(true, s.log.iter().any(|l| l.starts_with("UID EXPUNGE")));
1063 Ok(())
1064}
1065
1066
1067/// A move to the folder the message is in does nothing, and says so: never `Done` (QA mailA, 26
1068/// Oct 2026: Delete pressed in Trash answered Done and the page forgot a message the server kept).
1069#[tokio::test]
1070async fn test_move_to_its_own_folder_is_already_not_done_00() -> Outcome<()> {
1071 let mut s = account(PLAIN);
1072 let u = s.deliver("Trash", "t@x");
1073 let (caps, r) = res!(roles(&mut s).await);
1074 let mut e = entry(u, "t@x", Action::Trash);
1075 e.mailbox = "Trash".into();
1076 e.uid_validity = 300;
1077 req!(ActOutcome::Already("Trash".into()), res!(act(&mut s, &caps, &r, Provider::Steel, &e).await));
1078 req!(true, s.has("Trash", "t@x"));
1079 req!(false, s.log.iter().any(|l| l.contains("MOVE") || l.contains("COPY") || l.contains("STORE")), "{:?}", s.log);
1080 Ok(())
1081}
1082
1083/// Without MOVE, a retry after a cut between the COPY and the EXPUNGE finds the copy already in
1084/// the target (confirmed by FETCH) and does not copy again.
1085#[tokio::test]
1086async fn test_retried_copy_without_move_leaves_one_copy_00() -> Outcome<()> {
1087 let mut s = account("IMAP4rev1 UIDPLUS SPECIAL-USE");
1088 let u = s.deliver("INBOX", "a@x");
1089 // The first try's COPY landed; its STORE and EXPUNGE did not.
1090 s.deliver("Junk", "a@x");
1091 let (caps, r) = res!(roles(&mut s).await);
1092 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Junk)).await));
1093 let r = raw("a@x", 2025);
1094 req!(1, s.folders["Junk"].msgs.iter().filter(|m| m.raw == r).count(), "{:?}", s.log);
1095 req!(0, s.folders["INBOX"].msgs.len());
1096 Ok(())
1097}
1098
1099/// A copy leaves the source where it is; replayed after a cut between the COPY and its answer, it
1100/// finds the copy made and does not copy again; to its own folder it does nothing; with the
1101/// source gone it has nothing to copy.
1102#[tokio::test]
1103async fn test_copy_is_made_once_and_keeps_the_source_00() -> Outcome<()> {
1104 let mut s = account(PLAIN);
1105 let u = s.deliver("INBOX", "c@x");
1106 let (caps, r) = res!(roles(&mut s).await);
1107 let e = entry(u, "c@x", Action::Copy { to: Target::Path("Elsewhere".into()) });
1108 req!(false, e.action.removes());
1109 for _ in 0..2 {
1110 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &e).await));
1111 }
1112 req!((true, 1), (s.has("INBOX", "c@x"), s.folders["Elsewhere"].msgs.len()), "{:?}", s.log);
1113 req!(1, s.log.iter().filter(|l| l.starts_with("UID COPY")).count());
1114 let own = Entry { action: Action::Copy { to: Target::Inbox }, ..e.clone() };
1115 req!(ActOutcome::Already("INBOX".into()), res!(act(&mut s, &caps, &r, Provider::Steel, &own).await));
1116 if let Some(f) = s.folders.get_mut("INBOX") {
1117 f.msgs.clear();
1118 }
1119 req!(ActOutcome::Gone, res!(act(&mut s, &caps, &r, Provider::Steel, &e).await));
1120 req!(1, s.folders["Elsewhere"].msgs.len());
1121 Ok(())
1122}
1123
1124/// A byte-identical copy in the target flagged `\Deleted` (Thunderbird's mark-as-deleted model)
1125/// waits only for an expunge, so it is not the copy asked for: a copy is made, and so it is for a
1126/// move without MOVE retried after a cut.
1127#[tokio::test]
1128async fn test_a_deleted_copy_in_the_target_is_not_held_00() -> Outcome<()> {
1129 for caps in [PLAIN, "IMAP4rev1 UIDPLUS SPECIAL-USE"] {
1130 let mut s = account(caps);
1131 let u = s.deliver("INBOX", "c@x");
1132 let old = s.put("Elsewhere", &raw("c@x", 2025), &["\\Deleted"]);
1133 let (cs, r) = res!(roles(&mut s).await);
1134 let e = entry(u, "c@x", if caps == PLAIN { Action::Copy { to: Target::Path("Elsewhere".into()) } }
1135 else { Action::Move { to: Target::Path("Elsewhere".into()) } });
1136 req!(ActOutcome::Done, res!(act(&mut s, &cs, &r, Provider::Steel, &e).await));
1137 let live = s.folders["Elsewhere"].msgs.iter()
1138 .filter(|m| m.uid != old && m.raw == raw("c@x", 2025) && !m.flags.iter().any(|f| f == "\\Deleted")).count();
1139 req!(1, live, "{}: {:?}", caps, s.log);
1140 }
1141 Ok(())
1142}
1143
1144/// A Date's year outside 1970 to the current year and one gives no year: a spam `Date` never
1145/// names, or makes, an archive folder.
1146#[test]
1147fn test_date_year_takes_a_plausible_year_only_00() -> Outcome<()> {
1148 for (d, want) in [
1149 ("Sat, 1 Jan 0000 10:00:00 +0000", None),
1150 ("Fri, 31 Dec 9999 10:00:00 +0000", None),
1151 ("Wed, 31 Dec 1969 23:59:59 +0000", None),
1152 ("1 Jan 2028 10:00:00 +0000", None),
1153 ("Thu, 1 Jan 1970 00:00:00 +0000", Some(1970)),
1154 ("1 Jan 2027 10:00:00 +0000", Some(2027)),
1155 ("Mon, 16 Nov 2026 10:00:00 +0800", Some(2026)),
1156 ] {
1157 req!(want, date_year(d, 2026), "{:?}", d);
1158 }
1159 Ok(())
1160}
1161
1162/// The year a yearly archive files by is the Date header's, as written; one that does not read is
1163/// none, never a guess.
1164#[test]
1165fn test_date_year_reads_only_a_well_formed_date_00() -> Outcome<()> {
1166 for (d, want) in [
1167 ("Tue, 1 Jul 2025 09:00:00 +0000", Some(2025)),
1168 ("1 Jan 2026 00:00:01 -0800", Some(2026)),
1169 ("Thu, 31 Dec 98 23:59 GMT", Some(1998)), // obs-year, RFC 5322 4.3
1170 ("Mon, 2 Feb 07 10:00:00 EST", Some(2007)),
1171 ("Wed, 3 Mar 103 10:00:00 +0000", Some(2003)),
1172 ("", None),
1173 ("01-Jan-2025 09:00:00 +0000", None), // an INTERNALDATE is not a Date
1174 ("yesterday", None),
1175 ("Tue, 1 Jul +2025 09:00:00 +0000", None),
1176 ("Tue, 1 Foo 2025 09:00:00 +0000", None),
1177 ] {
1178 req!(want, date_year(d, 2026), "{:?}", d);
1179 }
1180 Ok(())
1181}
1182
1183/// Two archives of one new year in one batch: the roles were listed at its start, so the second
1184/// meets the folder the first created, and archives into it.
1185#[tokio::test]
1186async fn test_two_archives_of_a_new_year_in_one_batch_00() -> Outcome<()> {
1187 let mut s = account(PLAIN);
1188 let a = s.deliver("INBOX", "a@x");
1189 let b = s.deliver("INBOX", "b@x");
1190 let (caps, r) = res!(roles(&mut s).await);
1191 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &entry(a, "a@x", Action::Archive)).await));
1192 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &entry(b, "b@x", Action::Archive)).await));
1193 req!(true, s.has("Archive/2025", "a@x") && s.has("Archive/2025", "b@x"), "{:?}", s.log);
1194 req!(0, s.folders["INBOX"].msgs.len());
1195 Ok(())
1196}
1197
1198/// E1: a Message-ID that cannot be searched for is a definite `Stuck`, never an `Err` the journal
1199/// retries for ever; both where it is re-found after a renumbering and where its source is gone.
1200#[tokio::test]
1201async fn test_unsearchable_message_id_is_stuck_not_an_error_00() -> Outcome<()> {
1202 let mut s = account(PLAIN);
1203 let a = s.deliver("INBOX", "a@x");
1204 s.renumber("INBOX", 101);
1205 let gone = s.deliver("INBOX", "b@x");
1206 s.expunge("INBOX", gone);
1207 let (caps, r) = res!(roles(&mut s).await);
1208 let mut e = entry(a, "a@x", Action::Trash);
1209 e.message_id = "<\"a b\"@x>".into();
1210 let out = act(&mut s, &caps, &r, Provider::Steel, &e).await;
1211 req!(true, matches!(out, Ok(ActOutcome::Stuck(_))), "renumbered: {:?}", out);
1212 let mut e = entry(gone, "b@x", Action::Trash);
1213 e.uid_validity = 101;
1214 e.message_id = "<\"b\"@x>".into();
1215 let out = act(&mut s, &caps, &r, Provider::Steel, &e).await;
1216 req!(true, matches!(out, Ok(ActOutcome::Stuck(_))), "source gone: {:?}", out);
1217 req!(0, s.folders["Trash"].msgs.len());
1218 Ok(())
1219}
1220
1221/// E2, S8: with UIDVALIDITY unchanged, a removal confirms the UID's Message-ID and size first, so
1222/// a server that reuses a UID keeps the other message.
1223#[tokio::test]
1224async fn test_a_reused_uid_is_confirmed_before_removal_00() -> Outcome<()> {
1225 let mut s = account(PLAIN);
1226 let u = s.deliver("INBOX", "a@x");
1227 s.expunge("INBOX", u);
1228 s.deliver_at("INBOX", u, "other@x");
1229 let (caps, r) = res!(roles(&mut s).await);
1230 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Expunge)).await);
1231 req!(true, matches!(out, ActOutcome::Stuck(_)), "{:?}", out);
1232 req!(true, s.has("INBOX", "other@x"), "{:?}", s.log);
1233 req!(false, s.log.iter().any(|l| l.contains("EXPUNGE")), "{:?}", s.log);
1234 Ok(())
1235}
1236
1237/// E4: with no `\Archive` role and no archive named by the caller, an archive is stuck: no folder
1238/// name is guessed or created.
1239#[tokio::test]
1240async fn test_archive_without_a_role_or_a_configured_name_is_stuck_00() -> Outcome<()> {
1241 let mut s = account(PLAIN);
1242 let u = s.deliver("INBOX", "a@x");
1243 let caps = Caps::from_list(&res!(s.capabilities().await));
1244 let r = Roles::from_list(&res!(s.list().await));
1245 for p in [Provider::Steel, Provider::Office365] {
1246 let out = res!(act(&mut s, &caps, &r, p, &entry(u, "a@x", Action::Archive)).await);
1247 req!(true, matches!(out, ActOutcome::Stuck(_)), "{:?}: {:?}", p, out);
1248 }
1249 req!(false, s.log.iter().any(|l| l.starts_with("CREATE") || l.contains("MOVE")), "{:?}", s.log);
1250 req!(1, s.folders["INBOX"].msgs.len());
1251 // The caller's name, Thunderbird's here, where no folder has the role.
1252 let mut r = r;
1253 r.archive = Some("Archives".into());
1254 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Archive)).await));
1255 req!(true, s.has("Archives/2025", "a@x"), "{:?}", s.log);
1256 Ok(())
1257}
1258
1259/// E5: `file_sent` reads the Message-ID from the message and refuses one given apart that
1260/// disagrees, rather than search for a copy that can never appear and append on every retry.
1261#[tokio::test]
1262async fn test_file_sent_refuses_an_id_that_is_not_the_messages_00() -> Outcome<()> {
1263 let mut s = account(PLAIN);
1264 let (_, r) = res!(roles(&mut s).await);
1265 for _ in 0..2 {
1266 let out = file_sent(&mut s, &r, Provider::Steel, "<other@x>", &raw("s@x", 2025)).await;
1267 req!(true, out.is_err(), "{:?}", out);
1268 }
1269 let no_id = b"Subject: none\r\n\r\nbody\r\n";
1270 req!(true, file_sent(&mut s, &r, Provider::Steel, "", no_id).await.is_err());
1271 req!(0, s.folders["Sent"].msgs.len(), "{:?}", s.log);
1272 Ok(())
1273}
1274
1275// ┌───────────────────────────────────────────────────────────────────────────┐
1276// │ ARCHIVE AND FILING RULES, ROLES, LINKS, NAMES │
1277// └───────────────────────────────────────────────────────────────────────────┘
1278
1279#[tokio::test]
1280async fn test_archive_by_provider_rule_00() -> Outcome<()> {
1281 // Steel and the general case: Archive/<year>, created when absent.
1282 let mut s = account(PLAIN);
1283 let u = s.deliver("INBOX", "a@x");
1284 let (caps, r) = res!(roles(&mut s).await);
1285 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Archive)).await));
1286 req!(true, s.log.iter().any(|l| l == "CREATE Archive/2025"), "{:?}", s.log);
1287 req!(true, s.has("Archive/2025", "a@x"));
1288
1289 // Gmail: a MOVE to the \All role, flat, whatever it is called.
1290 let mut s = account(CONDSTORE);
1291 s.folder("[Gmail]/Alle Nachrichten", "\\All", 600);
1292 let u = s.deliver("INBOX", "g@x");
1293 let (caps, r) = res!(roles(&mut s).await);
1294 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Gmail, &entry(u, "g@x", Action::Archive)).await));
1295 req!(true, s.has("[Gmail]/Alle Nachrichten", "g@x"));
1296 req!(false, s.log.iter().any(|l| l.starts_with("CREATE")));
1297
1298 // Office 365: the \Archive role, flat.
1299 let mut s = account(PLAIN);
1300 s.folder("Archiv", "\\Archive", 700);
1301 let u = s.deliver("INBOX", "o@x");
1302 let (caps, r) = res!(roles(&mut s).await);
1303 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Office365, &entry(u, "o@x", Action::Archive)).await));
1304 req!(true, s.has("Archiv", "o@x"));
1305
1306 // Junk and not-junk.
1307 let (caps, r) = res!(roles(&mut s).await);
1308 let u = s.deliver("INBOX", "j@x");
1309 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "j@x", Action::Junk)).await));
1310 let ju = s.folders["Junk"].msgs[0].uid;
1311 let mut e = entry(ju, "j@x", Action::NotJunk);
1312 e.mailbox = "Junk".into();
1313 e.uid_validity = 400;
1314 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &e).await));
1315 req!(true, s.has("INBOX", "j@x"));
1316 Ok(())
1317}
1318
1319#[tokio::test]
1320async fn test_sent_filing_by_provider_rule_00() -> Outcome<()> {
1321 // Gmail and Office 365 file it themselves: never APPEND, even with no copy there yet.
1322 for p in [Provider::Gmail, Provider::Office365] {
1323 let mut s = account(CONDSTORE);
1324 let (_, r) = res!(roles(&mut s).await);
1325 req!(Filed::Server, res!(file_sent(&mut s, &r, p, "<s@x>", &raw("s@x", 2025)).await));
1326 req!(false, s.log.iter().any(|l| l.starts_with("APPEND")));
1327 }
1328 // Steel appends when a confirmed search finds none, and not when it finds one.
1329 let mut s = account(PLAIN);
1330 let (_, r) = res!(roles(&mut s).await);
1331 req!(true, matches!(res!(file_sent(&mut s, &r, Provider::Steel, "<s@x>", &raw("s@x", 2025)).await),
1332 Filed::Appended(_)));
1333 req!(Filed::Already, res!(file_sent(&mut s, &r, Provider::Steel, "<s@x>", &raw("s@x", 2025)).await));
1334 req!(1, s.folders["Sent"].msgs.len());
1335 Ok(())
1336}
1337
1338/// A role is found by its attribute, never by a folder's name.
1339#[tokio::test]
1340async fn test_roles_by_special_use_never_by_name_00() -> Outcome<()> {
1341 let mut s = Server::new(PLAIN);
1342 s.folder("Sent", "", 1);
1343 s.folder("Trash", "", 2);
1344 s.folder("[Gmail]/Gesendet", "\\Sent", 3);
1345 let r = Roles::from_list(&res!(s.list().await));
1346 req!(Some("[Gmail]/Gesendet"), r.role(SpecialUse::Sent));
1347 req!(true, r.role(SpecialUse::Trash).is_none());
1348 let synced = r.synced();
1349 req!("INBOX", synced[0].as_str());
1350 req!(4, synced.len());
1351 // With no Trash role a trash is stuck, never filed by a guessed name.
1352 let caps = Caps::from_list(&s.caps);
1353 let u = s.deliver("INBOX", "a@x");
1354 req!(true, matches!(res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Trash)).await),
1355 ActOutcome::Stuck(_)));
1356 let e = entry(u, "a@x", Action::Move { to: Target::Role(SpecialUse::Sent) });
1357 req!(ActOutcome::Done, res!(act(&mut s, &caps, &r, Provider::Steel, &e).await));
1358 req!(true, s.has("[Gmail]/Gesendet", "a@x"));
1359 Ok(())
1360}
1361
1362/// Copies are linked by Message-ID, and by X-GM-MSGID only where the server advertises it.
1363#[tokio::test]
1364async fn test_links_by_message_id_and_gm_msgid_only_where_advertised_00() -> Outcome<()> {
1365 for (caps, gm) in [(PLAIN, false), (CONDSTORE, true)] {
1366 let mut s = Server::new(caps);
1367 s.deliver("INBOX", "l@x");
1368 let mut st = Store::default();
1369 let d = res!(round(&mut s, &mut st, &Budget::default(), &[]).await);
1370 let want = if gm { LinkKey::GmMsgId(1) } else { LinkKey::MessageId("l@x".into()) };
1371 let ok = d.new[0].link == Some(want);
1372 req!(true, ok, "{:?}", d.new[0].link);
1373 }
1374 let mut m = FetchedMessage { gm_msgid: Some(9), ..Default::default() };
1375 m.body = raw("z@x", 2025);
1376 req!(Some(LinkKey::MessageId("z@x".into())), link_key(&m, false));
1377 Ok(())
1378}
1379
1380#[test]
1381fn test_maildir_name_is_keyed_and_round_trips_00() -> Outcome<()> {
1382 let key = MsgKey { uid_validity: 7, uid: 42 };
1383 let n = maildir_name(key, &["\\Seen".into(), "\\Flagged".into(), "$Label".into()]);
1384 req!("7.42:2,FS", n.as_str());
1385 let (k, f) = res!(parse_maildir_name(&n).ok_or_else(|| err!("unparsed"; Invalid)));
1386 req!(key, k);
1387 req!(vec!["\\Flagged".to_string(), "\\Seen".to_string()], f);
1388 Ok(())
1389}
1390
1391
1392// ┌───────────────────────────────────────────────────────────────────────────┐
1393// │ QUERIES │
1394// └───────────────────────────────────────────────────────────────────────────┘
1395
1396/// Gmail's shape: its roles under `[Gmail]/`, Sent localised, a plain label and a `\Noselect`
1397/// parent, so a role is found only by its attribute.
1398#[tokio::test]
1399async fn test_folders_finds_all_mail_and_sent_by_role_on_gmail_00() -> Outcome<()> {
1400 use oxedyne_fe2o3_mail::sync::query::{self, Limits, Role};
1401 let mut s = Server::new("IMAP4rev1 CONDSTORE X-GM-EXT-1");
1402 s.folder("[Gmail]", "\\Noselect \\HasChildren", 1);
1403 s.folder("[Gmail]/All Mail", "\\All \\HasNoChildren", 2);
1404 s.folder("[Gmail]/Gesendet", "\\Sent \\HasNoChildren", 3);
1405 s.folder("[Gmail]/Drafts", "\\Drafts", 4);
1406 s.folder("[Gmail]/Bin", "\\Trash", 5);
1407 s.folder("Sent", "", 6); // a label a user named Sent, which is not the role
1408 for i in 0..3 {
1409 s.deliver("[Gmail]/All Mail", &fmt!("a{}", i));
1410 }
1411 s.deliver("[Gmail]/Gesendet", "s0");
1412 let lim = Limits { max_rows: 10, max_read_bytes: 1000, max_folders: 100 };
1413 let (roles, fs) = res!(query::folders(&mut s, &lim).await);
1414 let role_of = |r: Role| fs.iter().find(|f| f.role == Some(r)).map(|f| (f.name.as_str(), f.count));
1415 assert_eq!(role_of(Role::Use(SpecialUse::All)), Some(("[Gmail]/All Mail", Some(3))));
1416 assert_eq!(role_of(Role::Use(SpecialUse::Sent)), Some(("[Gmail]/Gesendet", Some(1))));
1417 assert_eq!(role_of(Role::Inbox), Some(("INBOX", Some(0))));
1418 assert_eq!(fs.iter().find(|f| f.name == "Sent").map(|f| f.role), Some(None),
1419 "a folder named Sent without the attribute was given the role");
1420 assert!(!fs.iter().any(|f| f.name == "[Gmail]"), "a \\Noselect parent was listed");
1421 assert_eq!(res!(query::resolve(&roles, &Target::Role(SpecialUse::Sent))), "[Gmail]/Gesendet");
1422 Ok(())
1423}
1424
1425/// The read-only queries open their folder with `EXAMINE`, never `SELECT` (mail design I7), so
1426/// the session they leave behind can write no flag.
1427#[tokio::test]
1428async fn test_queries_open_with_examine_00() -> Outcome<()> {
1429 use oxedyne_fe2o3_mail::sync::query;
1430 let mut s = account("");
1431 s.deliver("INBOX", "a@x");
1432 let (_, roles) = res!(roles(&mut s).await);
1433 let lim = query::Limits { max_rows: 10, max_read_bytes: 1000, max_folders: 10 };
1434 res!(query::list(&mut s, &roles, &Target::Inbox, &query::Range::default(), &lim).await);
1435 res!(query::raw(&mut s, &roles, &Target::Inbox, 1, 100).await);
1436 let opens: Vec<&String> = s.log.iter()
1437 .filter(|l| l.starts_with("SELECT") || l.starts_with("EXAMINE")).collect();
1438 assert_eq!(opens, vec!["EXAMINE INBOX ", "EXAMINE INBOX "], "a query opened with SELECT");
1439 assert!(s.uid_store_flags(&UidSet::from([1u32]), &["\\Seen"], &[]).await.is_err(),
1440 "a flag write was taken after a query");
1441 Ok(())
1442}
1443// ┌───────────────────────────────────────────────────────────────────────────┐
1444// │ DRAFTS SAVED OVER THEIR EARLIER VERSION │
1445// └───────────────────────────────────────────────────────────────────────────┘
1446
1447fn drafts(caps: &str) -> Server {
1448 let mut s = account(caps);
1449 s.folder("Drafts", "\\Drafts", 800);
1450 s
1451}
1452
1453fn draft(text: &str) -> Vec<u8> {
1454 fmt!("Message-ID: <d@his.example>\r\nSubject: d\r\n\r\n{}\r\n", text).into_bytes()
1455}
1456
1457/// The earlier version, as the caller holds it.
1458fn old_draft(s: &mut Server, mb: &str, text: &str) -> Entry {
1459 let raw = draft(text);
1460 let uid = s.put(mb, &raw, &["\\Draft", "\\Seen"]);
1461 Entry {
1462 mailbox: mb.into(), uid_validity: s.folders[mb].uv, uid,
1463 message_id: "<d@his.example>".into(), size: raw.len() as u32, ..Default::default()
1464 }
1465}
1466
1467fn bodies(s: &Server, mb: &str) -> Vec<Vec<u8>> {
1468 s.folders[mb].msgs.iter().map(|m| m.raw.clone()).collect()
1469}
1470
1471/// S1, E3: Drafts renumbered after the APPEND, the old version expunged by another session first,
1472/// the new one the same size: the new one is never taken for the old.
1473#[tokio::test]
1474async fn test_draft_renumbered_after_append_is_never_removed_00() -> Outcome<()> {
1475 let mut s = drafts(PLAIN);
1476 let old = old_draft(&mut s, "Drafts", "abcd");
1477 s.on_append = Some(|s: &mut Server| {
1478 let u = s.folders["Drafts"].msgs[0].uid;
1479 s.expunge("Drafts", u);
1480 s.renumber("Drafts", 801);
1481 });
1482 let (caps, r) = res!(roles(&mut s).await);
1483 let new = draft("abce");
1484 let out = res!(save_draft(&mut s, &caps, &r, &new, Some(&old)).await);
1485 req!(true, matches!(out, Saved::OldGone(_) | Saved::OldLeft(..)), "{:?}", out);
1486 req!(vec![new.clone()], bodies(&s, "Drafts"));
1487 req!(vec!["\\Draft".to_string(), "\\Seen".to_string()], s.folders["Drafts"].msgs[0].flags.clone());
1488 req!(false, s.log.iter().any(|l| l.contains("EXPUNGE")), "{:?}", s.log);
1489 Ok(())
1490}
1491
1492/// S2: an APPEND cut before the server has it, and one cut after it is stored: the old version
1493/// stays across the cut, and the retry leaves the new one once.
1494#[tokio::test]
1495async fn test_draft_append_cut_then_retried_leaves_one_00() -> Outcome<()> {
1496 for cut in [Answer::CutBefore, Answer::CutAfter] {
1497 let mut s = drafts(PLAIN);
1498 let old = old_draft(&mut s, "Drafts", "abcd");
1499 let (caps, r) = res!(roles(&mut s).await);
1500 let new = draft("abce");
1501 s.answer = cut;
1502 req!(true, save_draft(&mut s, &caps, &r, &new, Some(&old)).await.is_err());
1503 req!(true, s.folders["Drafts"].msgs.iter().any(|m| m.uid == old.uid), "{:?}", cut);
1504 let out = res!(save_draft(&mut s, &caps, &r, &new, Some(&old)).await);
1505 req!(true, matches!(out, Saved::Replaced(Some(_))), "{:?}: {:?}", cut, out);
1506 req!(vec![new.clone()], bodies(&s, "Drafts"), "{:?}: {:?}", cut, s.log);
1507 }
1508 Ok(())
1509}
1510
1511/// S3: a draft whose Message-ID is missing or cannot be searched for is refused before any
1512/// APPEND, since a retry could not tell it was saved; a folded one is read unfolded.
1513#[tokio::test]
1514async fn test_draft_without_a_searchable_id_is_refused_before_append_00() -> Outcome<()> {
1515 let mut s = drafts(PLAIN);
1516 let old = old_draft(&mut s, "Drafts", "abcd");
1517 let (caps, r) = res!(roles(&mut s).await);
1518 for bad in [&b"Subject: d\r\n\r\nx\r\n"[..], &b"Message-ID: <\"a b\"@his.example>\r\n\r\nx\r\n"[..]] {
1519 let out = res!(save_draft(&mut s, &caps, &r, bad, Some(&old)).await);
1520 req!(true, matches!(out, Saved::Refused(_)), "{:?}", out);
1521 }
1522 req!(false, s.log.iter().any(|l| l.starts_with("APPEND")), "{:?}", s.log);
1523 let folded = b"Message-ID:\r\n <d@his.example>\r\nSubject: d\r\n\r\nfolded\r\n".to_vec();
1524 let out = res!(save_draft(&mut s, &caps, &r, &folded, Some(&old)).await);
1525 req!(true, matches!(out, Saved::Replaced(_)), "{:?}", out);
1526 req!(vec![folded.clone()], bodies(&s, "Drafts"));
1527 Ok(())
1528}
1529
1530/// S4: a refused APPEND reaches the caller in the server's words, and the old version is untouched.
1531#[tokio::test]
1532async fn test_draft_append_refused_leaves_the_old_untouched_00() -> Outcome<()> {
1533 for w in ["NO [OVERQUOTA] Quota exceeded", "NO [TRYCREATE] No such mailbox", "BAD Bad literal",
1534 "BYE Server shutting down"]
1535 {
1536 let mut s = drafts(PLAIN);
1537 let old = old_draft(&mut s, "Drafts", "abcd");
1538 let (caps, r) = res!(roles(&mut s).await);
1539 s.answer = Answer::Refuse(w);
1540 let out = save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await;
1541 req!(true, out.is_err() && fmt!("{:?}", out).contains(w), "{:?}", out);
1542 req!(vec![draft("abcd")], bodies(&s, "Drafts"));
1543 req!(false, s.log.iter().any(|l| l.contains("STORE") || l.contains("EXPUNGE")
1544 || l.starts_with("CREATE")), "{:?}", s.log);
1545 }
1546 Ok(())
1547}
1548
1549/// S5: another client acts on the old version between our APPEND and its removal: it saves its
1550/// own version and removes the old, removes it only, or sends it. Nothing of its is removed.
1551#[tokio::test]
1552async fn test_draft_second_client_mid_save_loses_nothing_00() -> Outcome<()> {
1553 let cases: [(fn(&mut Server), usize, usize); 3] = [
1554 (|s| {
1555 s.put("Drafts", &draft("thunderbird's"), &["\\Draft"]);
1556 let u = s.folders["Drafts"].msgs[0].uid;
1557 s.expunge("Drafts", u);
1558 }, 2, 0),
1559 (|s| {
1560 let u = s.folders["Drafts"].msgs[0].uid;
1561 s.expunge("Drafts", u);
1562 }, 1, 0),
1563 (|s| {
1564 let m = s.folders["Drafts"].msgs[0].clone();
1565 s.put("Sent", &m.raw, &["\\Seen"]);
1566 s.expunge("Drafts", m.uid);
1567 }, 1, 1),
1568 ];
1569 for (hook, in_drafts, in_sent) in cases {
1570 let mut s = drafts(PLAIN);
1571 let old = old_draft(&mut s, "Drafts", "abcd");
1572 let (caps, r) = res!(roles(&mut s).await);
1573 s.on_append = Some(hook);
1574 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
1575 req!(true, matches!(out, Saved::OldGone(Some(_))), "{:?}", out);
1576 req!(in_drafts, s.folders["Drafts"].msgs.len(), "{:?}", s.log);
1577 req!(true, bodies(&s, "Drafts").contains(&draft("abce")));
1578 req!(in_sent, s.folders["Sent"].msgs.len());
1579 req!(false, s.log.iter().any(|l| l.contains("EXPUNGE") || l.contains("SELECT Sent")), "{:?}", s.log);
1580 }
1581 Ok(())
1582}
1583
1584/// S6: without UIDPLUS the old version is left, unflagged, beside the new; with UIDPLUS but no
1585/// APPENDUID it is still told from the new one and removed.
1586#[tokio::test]
1587async fn test_draft_by_server_capability_00() -> Outcome<()> {
1588 let mut s = drafts("IMAP4rev1 SPECIAL-USE");
1589 let old = old_draft(&mut s, "Drafts", "abcd");
1590 let (caps, r) = res!(roles(&mut s).await);
1591 s.answer = Answer::NoUid;
1592 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
1593 req!(true, matches!(&out, Saved::OldLeft(None, w) if w.contains("UIDPLUS")), "{:?}", out);
1594 req!(2, s.folders["Drafts"].msgs.len());
1595 req!(false, s.log.iter().any(|l| l.contains("STORE") || l.contains("EXPUNGE")), "{:?}", s.log);
1596
1597 let mut s = drafts("IMAP4rev1 UIDPLUS SPECIAL-USE");
1598 let old = old_draft(&mut s, "Drafts", "abcd");
1599 let (caps, r) = res!(roles(&mut s).await);
1600 s.answer = Answer::NoUid;
1601 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
1602 req!(Saved::Replaced(None), out);
1603 req!(vec![draft("abce")], bodies(&s, "Drafts"));
1604 Ok(())
1605}
1606
1607/// S7: no `\Drafts` role refuses, with no folder guessed or made; of two, the first is saved to
1608/// and an old version in the second removed; an old version outside a drafts folder is kept.
1609#[tokio::test]
1610async fn test_draft_by_role_never_by_name_00() -> Outcome<()> {
1611 let mut s = account(PLAIN);
1612 s.folder("Drafts", "", 800);
1613 let old = old_draft(&mut s, "Drafts", "abcd");
1614 let (caps, r) = res!(roles(&mut s).await);
1615 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
1616 req!(true, matches!(out, Saved::Refused(_)), "{:?}", out);
1617 req!(false, s.log.iter().any(|l| l.starts_with("APPEND") || l.starts_with("CREATE")), "{:?}", s.log);
1618
1619 let mut s = drafts(PLAIN);
1620 s.folder("INBOX.Drafts", "\\Drafts", 810);
1621 let old = old_draft(&mut s, "INBOX.Drafts", "abcd");
1622 let (caps, r) = res!(roles(&mut s).await);
1623 req!(Saved::Replaced(Some(AppendUid { uid_validity: 800, uid: 1 })),
1624 res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await));
1625 req!(0, s.folders["INBOX.Drafts"].msgs.len());
1626
1627 let mut s = drafts(PLAIN);
1628 let old = old_draft(&mut s, "INBOX", "abcd");
1629 let (caps, r) = res!(roles(&mut s).await);
1630 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
1631 req!(true, matches!(out, Saved::OldLeft(Some(_), _)), "{:?}", out);
1632 req!(vec![draft("abcd")], bodies(&s, "INBOX"));
1633 Ok(())
1634}
1635
1636/// S8: the old version's UID reused for another message with UIDVALIDITY unchanged: that message
1637/// is kept.
1638#[tokio::test]
1639async fn test_draft_old_uid_reused_keeps_the_other_message_00() -> Outcome<()> {
1640 let mut s = drafts(PLAIN);
1641 let old = old_draft(&mut s, "Drafts", "abcd");
1642 s.on_append = Some(|s: &mut Server| {
1643 let u = s.folders["Drafts"].msgs[0].uid;
1644 s.expunge("Drafts", u);
1645 s.deliver_at("Drafts", u, "template@x");
1646 });
1647 let (caps, r) = res!(roles(&mut s).await);
1648 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
1649 req!(true, matches!(&out, Saved::OldLeft(_, w) if w.contains("Message-ID differs")), "{:?}", out);
1650 req!(true, s.has("Drafts", "template@x"), "{:?}", s.log);
1651 req!(2, s.folders["Drafts"].msgs.len());
1652 Ok(())
1653}
1654
1655/// P1, P2: the provider read from capabilities and the caller's table decides the Sent filing.
1656#[tokio::test]
1657async fn test_provider_of_drives_the_sent_filing_00() -> Outcome<()> {
1658 let t = vec![("mail.his.example".to_string(), Provider::Steel)];
1659 for (cl, host, appended) in [(PLAIN, "MAIL.his.example.", true), (PLAIN, "other.example", true),
1660 (CONDSTORE, "mail.his.example", false)]
1661 {
1662 let mut s = account(cl);
1663 let (caps, r) = res!(roles(&mut s).await);
1664 let p = Provider::of(&caps, host, &t);
1665 let f = res!(file_sent(&mut s, &r, p, "<s@x>", &raw("s@x", 2025)).await);
1666 req!(appended, matches!(f, Filed::Appended(_)), "{}: {:?} {:?}", host, p, f);
1667 }
1668 Ok(())
1669}
1670
1671// ┌───────────────────────────────────────────────────────────────────────────┐
1672// │ FIX ROUND 1: EVERY REMOVAL CONFIRMS (the examiner's cases as written) │
1673// └───────────────────────────────────────────────────────────────────────────┘
1674
1675
1676/// G3: the caller's old draft gives no Message-ID, and no size or a size alone: its UID now names
1677/// another message (a template) of that size. A removal must not take it.
1678#[tokio::test]
1679async fn mailfex_c1_old_with_neither_id_nor_size_keeps_a_reused_uid() -> Outcome<()> {
1680 for size in [0, raw("template@x", 2025).len() as u32] {
1681 let mut s = drafts(PLAIN);
1682 let mut old = old_draft(&mut s, "Drafts", "abcd");
1683 old.message_id = String::new();
1684 old.size = size;
1685 s.on_append = Some(|s: &mut Server| {
1686 let u = s.folders["Drafts"].msgs[0].uid;
1687 s.expunge("Drafts", u);
1688 s.deliver_at("Drafts", u, "template@x");
1689 });
1690 let (caps, r) = res!(roles(&mut s).await);
1691 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
1692 req!(true, s.has("Drafts", "template@x"), "{}: out {:?} log {:?}", size, out, s.log);
1693 }
1694 Ok(())
1695}
1696
1697
1698/// E1: an unchanged draft saved again where the server answers OK without APPENDUID.
1699#[tokio::test]
1700async fn mailfex_c6_unchanged_draft_without_appenduid() -> Outcome<()> {
1701 let mut s = drafts(PLAIN);
1702 let old = old_draft(&mut s, "Drafts", "abcd");
1703 let (caps, r) = res!(roles(&mut s).await);
1704 s.answer = Answer::NoUid;
1705 let out = res!(save_draft(&mut s, &caps, &r, &draft("abcd"), Some(&old)).await);
1706 req!(1, s.folders["Drafts"].msgs.len(), "{:?} {:?}", out, s.log);
1707 Ok(())
1708}
1709
1710/// Every verb that takes a mail away confirms a reused UID first: an entry that gives nothing, a
1711/// size alone, or a Message-ID or size the message there lacks leaves that message where it is,
1712/// and says why.
1713#[tokio::test]
1714async fn test_every_removal_confirms_a_reused_uid_00() -> Outcome<()> {
1715 let verbs = [Action::Expunge, Action::Trash, Action::Junk, Action::Archive,
1716 Action::Move { to: Target::Path("Elsewhere".into()) }];
1717 for v in verbs {
1718 for (give, why) in [("neither", "no size"), ("size", "Message-ID differs"),
1719 ("other id", "Message-ID differs"), ("other size", "size differs")]
1720 {
1721 let mut s = account(PLAIN);
1722 let u = s.deliver("INBOX", "a@x");
1723 s.expunge("INBOX", u);
1724 s.deliver_at("INBOX", u, "other@x");
1725 let (caps, r) = res!(roles(&mut s).await);
1726 let mut e = entry(u, "a@x", v.clone());
1727 match give {
1728 "neither" => { e.message_id.clear(); e.size = 0; }
1729 "size" => { e.message_id.clear(); e.size = raw("other@x", 2025).len() as u32; }
1730 "other size"=> { e.message_id = "<other@x>".into(); e.size += 7; }
1731 _ => {}
1732 }
1733 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
1734 req!(true, matches!(&out, ActOutcome::Stuck(w) if w.contains(why)), "{:?}, {}: {:?}", v, give, out);
1735 req!(true, s.has("INBOX", "other@x") && !s.log.iter().any(|l| l.contains("STORE")
1736 || l.contains("MOVE") || l.contains("COPY") || l.contains("EXPUNGE")),
1737 "{:?}, {}: {:?} {:?}", v, give, out, s.log);
1738 }
1739 }
1740 Ok(())
1741}
1742
1743/// An earlier draft with no Message-ID (another client's) is replaced when the size and
1744/// INTERNALDATE the caller holds agree with the server's, and left when the date does not.
1745#[tokio::test]
1746async fn test_draft_without_message_id_replaced_by_size_and_date_00() -> Outcome<()> {
1747 for (date, replaced) in [("01-Jan-2025 09:00:00 +0000", true), ("02-Jan-2025 09:00:00 +0000", false)] {
1748 let mut s = drafts(PLAIN);
1749 let raw0 = b"Subject: d\r\n\r\nno id\r\n".to_vec();
1750 let uid = s.put("Drafts", &raw0, &["\\Draft"]);
1751 let old = Entry { mailbox: "Drafts".into(), uid_validity: 800, uid, size: raw0.len() as u32,
1752 internal_date: date.into(), ..Default::default() };
1753 let (caps, r) = res!(roles(&mut s).await);
1754 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
1755 req!(replaced, matches!(out, Saved::Replaced(_)), "{}: {:?} {:?}", date, out, s.log);
1756 req!(!replaced, bodies(&s, "Drafts").contains(&raw0));
1757 req!(!replaced, matches!(&out, Saved::OldLeft(_, w) if w.contains("date differs")), "{:?}", out);
1758 }
1759 Ok(())
1760}
1761
1762
1763/// An INTERNALDATE confirms as an instant, whatever its offset; one that does not parse confirms
1764/// nothing, even where the two strings agree.
1765#[tokio::test]
1766async fn test_internal_date_confirms_as_an_instant_00() -> Outcome<()> {
1767 for (there, held, confirmed) in [
1768 ("17-Nov-2026 09:00:00 +0800", "17-Nov-2026 01:00:00 +0000", true),
1769 (" 7-Nov-2026 09:00:00 -0130", "07-Nov-2026 10:30:00 +0000", true),
1770 ("17-Nov-2026 09:00:00 +0800", "17-Nov-2026 09:00:00 +0000", false),
1771 ("17-Nov-2026 09:00 +0800", "17-Nov-2026 09:00 +0800", false),
1772 ] {
1773 let mut s = account(PLAIN);
1774 let raw0 = b"Subject: t\r\n\r\nno id\r\n".to_vec();
1775 let u = s.put("INBOX", &raw0, &[]);
1776 s.dates.insert(u, there.into());
1777 let (caps, r) = res!(roles(&mut s).await);
1778 let e = Entry { mailbox: "INBOX".into(), uid_validity: 100, uid: u, size: raw0.len() as u32,
1779 internal_date: held.into(), action: Action::Expunge, ..Default::default() };
1780 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
1781 req!(confirmed, out == ActOutcome::Done, "{} / {}: {:?}", there, held, out);
1782 req!(!confirmed, matches!(&out, ActOutcome::Stuck(w) if w.contains("date")), "{:?}", out);
1783 req!(!confirmed, present(&s, "INBOX", &raw0));
1784 }
1785 Ok(())
1786}
1787
1788/// A copy of the same bytes flagged `\Deleted`, the old version or one left by a cut, is not a
1789/// kept draft: the draft is saved anew, and nothing of his text waits on another's EXPUNGE.
1790#[tokio::test]
1791async fn test_a_deleted_copy_is_not_an_unchanged_draft_00() -> Outcome<()> {
1792 for old_marked in [true, false] {
1793 let mut s = drafts(PLAIN);
1794 let old = old_draft(&mut s, "Drafts", if old_marked { "abcd" } else { "abce" });
1795 let cut = s.put("Drafts", &draft("abcd"), &["\\Draft"]);
1796 s.set_flags("Drafts", if old_marked { old.uid } else { cut }, &["\\Draft", "\\Deleted"]);
1797 let (caps, r) = res!(roles(&mut s).await);
1798 let out = res!(save_draft(&mut s, &caps, &r, &draft("abcd"), Some(&old)).await);
1799 req!(true, matches!(out, Saved::Replaced(Some(_))), "{}: {:?} {:?}", old_marked, out, s.log);
1800 req!(true, s.folders["Drafts"].msgs.iter().any(|m| m.raw == draft("abcd")
1801 && !m.flags.iter().any(|f| f == "\\Deleted")), "{:?}", s.log);
1802 }
1803 Ok(())
1804}
1805
1806
1807// ┌───────────────────────────────────────────────────────────────────────────┐
1808// │ MAILfe-x2: the second examination's cases │
1809// └───────────────────────────────────────────────────────────────────────────┘
1810
1811fn present(s: &Server, mb: &str, raw: &[u8]) -> bool {
1812 s.folders[mb].msgs.iter().any(|m| m.raw == raw)
1813}
1814
1815fn sent_any(s: &Server) -> bool {
1816 s.log.iter().any(|l| l.contains("STORE") || l.contains("MOVE") || l.contains("COPY")
1817 || l.contains("EXPUNGE"))
1818}
1819
1820/// M3: a message with no Message-ID, its INTERNALDATE given by the server at another offset of
1821/// the same instant than the entry holds. Expunge must not say Gone while it is there.
1822#[tokio::test]
1823async fn x2_m3_zone_expunge() -> Outcome<()> {
1824 let mut s = account(PLAIN);
1825 let raw0 = b"Subject: t\r\n\r\nno id\r\n".to_vec();
1826 let u = s.put("INBOX", &raw0, &[]);
1827 s.dates.insert(u, "17-Nov-2026 09:00:00 +0800".into());
1828 let (caps, r) = res!(roles(&mut s).await);
1829 let e = Entry { mailbox: "INBOX".into(), uid_validity: 100, uid: u, size: raw0.len() as u32,
1830 internal_date: "17-Nov-2026 01:00:00 +0000".into(), action: Action::Expunge, ..Default::default() };
1831 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
1832 let there = present(&s, "INBOX", &raw0);
1833 eprintln!("X2 m3_zone_expunge out={:?} still_there={} log={:?}", out, there, s.log);
1834 req!(false, out == ActOutcome::Gone && there, "out {:?} log {:?}", out, s.log);
1835 Ok(())
1836}
1837
1838/// M3: the same for an earlier draft with no Message-ID (another client's).
1839#[tokio::test]
1840async fn x2_m3_zone_draft() -> Outcome<()> {
1841 let mut s = drafts(PLAIN);
1842 let raw0 = b"Subject: d\r\n\r\nno id\r\n".to_vec();
1843 let u = s.put("Drafts", &raw0, &["\\Draft"]);
1844 s.dates.insert(u, "17-Nov-2026 09:00:00 +0800".into());
1845 let old = Entry { mailbox: "Drafts".into(), uid_validity: 800, uid: u, size: raw0.len() as u32,
1846 internal_date: "17-Nov-2026 01:00:00 +0000".into(), ..Default::default() };
1847 let (caps, r) = res!(roles(&mut s).await);
1848 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
1849 let there = present(&s, "Drafts", &raw0);
1850 eprintln!("X2 m3_zone_draft out={:?} old_still_there={} n={} log={:?}", out, there,
1851 s.folders["Drafts"].msgs.len(), s.log);
1852 req!(false, matches!(out, Saved::OldGone(_)) && there, "out {:?} log {:?}", out, s.log);
1853 Ok(())
1854}
1855
1856/// M3: two templates with no Message-ID, the same size and the same date; the first's UID reused
1857/// by the second (a server breaking RFC 3501). The ruling accepts the match; shown, not judged.
1858#[tokio::test]
1859async fn x2_m3_same_size_same_date_reused() -> Outcome<()> {
1860 let mut s = account(PLAIN);
1861 let a = b"Subject: t\r\n\r\ntemplate A\r\n".to_vec();
1862 let b = b"Subject: t\r\n\r\ntemplate B\r\n".to_vec();
1863 let u = s.put("INBOX", &a, &[]);
1864 s.expunge("INBOX", u);
1865 let f = s.folders.get_mut("INBOX").unwrap();
1866 f.msgs.push(Msg { uid: u, flags: Vec::new(), raw: b.clone(), modseq: 9, gm: 0 });
1867 let (caps, r) = res!(roles(&mut s).await);
1868 let e = Entry { mailbox: "INBOX".into(), uid_validity: 100, uid: u, size: a.len() as u32,
1869 internal_date: "01-Jan-2025 09:00:00 +0000".into(), action: Action::Trash, ..Default::default() };
1870 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
1871 eprintln!("X2 m3_same out={:?} b_kept={} log={:?}", out, present(&s, "INBOX", &b), s.log);
1872 Ok(())
1873}
1874
1875/// M2: the verbs the round's table case leaves out (Not junk, Flags add and remove), and the
1876/// rows it leaves out (date only), on a reused UID: nothing sent.
1877#[tokio::test]
1878async fn x2_m2_other_verbs_and_date_only() -> Outcome<()> {
1879 let verbs = [Action::NotJunk, Action::Flags { add: vec!["\\Seen".into()], remove: vec![] },
1880 Action::Flags { add: vec![], remove: vec!["\\Flagged".into()] }, Action::Expunge,
1881 Action::Move { to: Target::Role(SpecialUse::Trash) }];
1882 for v in verbs {
1883 for give in ["neither", "size", "date", "other id"] {
1884 let mut s = account(PLAIN);
1885 let mb = if v == Action::NotJunk { "Junk" } else { "INBOX" };
1886 let u = s.deliver(mb, "a@x");
1887 s.set_flags(mb, u, &["\\Flagged"]);
1888 s.expunge(mb, u);
1889 s.deliver_at(mb, u, "other@x");
1890 s.set_flags(mb, u, &["\\Flagged"]);
1891 let (caps, r) = res!(roles(&mut s).await);
1892 let mut e = entry(u, "a@x", v.clone());
1893 e.mailbox = mb.into();
1894 e.uid_validity = s.folders[mb].uv;
1895 match give {
1896 "neither" => { e.message_id.clear(); e.size = 0; e.internal_date.clear(); }
1897 "size" => { e.message_id.clear(); e.internal_date.clear(); }
1898 "date" => { e.message_id.clear(); e.size = 0; }
1899 _ => {}
1900 }
1901 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
1902 eprintln!("X2 m2 {:?} {}: {:?} sent={}", v, give, out, sent_any(&s));
1903 req!(false, sent_any(&s), "{:?}, {}: {:?} {:?}", v, give, out, s.log);
1904 }
1905 }
1906 Ok(())
1907}
1908
1909/// M2: the right Message-ID and a wrong size (a server whose RFC822.SIZE moved): the message is
1910/// still there. What does each verb tell him?
1911#[tokio::test]
1912async fn x2_m2_right_id_wrong_size() -> Outcome<()> {
1913 let verbs = [Action::Expunge, Action::Trash, Action::Flags { add: vec!["\\Seen".into()], remove: vec![] }];
1914 let mut bad = Vec::new();
1915 for v in verbs {
1916 let mut s = account(PLAIN);
1917 let u = s.deliver("INBOX", "a@x");
1918 let (caps, r) = res!(roles(&mut s).await);
1919 let mut e = entry(u, "a@x", v.clone());
1920 e.size += 7;
1921 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
1922 eprintln!("X2 m2_size {:?}: {:?} still_there={} log={:?}", v, out, s.has("INBOX", "a@x"), s.log);
1923 if matches!(out, ActOutcome::Gone | ActOutcome::Lost) && s.has("INBOX", "a@x") {
1924 bad.push(fmt!("{:?} -> {:?}", v, out));
1925 }
1926 }
1927 req!(0, bad.len(), "said gone or lost while there: {:?}", bad);
1928 Ok(())
1929}
1930
1931/// M4: the Meta FETCH answered for another UID, then for none of its INTERNALDATE.
1932#[tokio::test]
1933async fn x2_m4_meta_garbled() -> Outcome<()> {
1934 for how in ["other uid", "no date"] {
1935 let mut s = account(PLAIN);
1936 let raw0 = b"Subject: t\r\n\r\nno id\r\n".to_vec();
1937 let u = s.put("INBOX", &raw0, &[]);
1938 match how {
1939 "other uid" => s.meta_for = Some(u + 40),
1940 _ => { s.dates.insert(u, String::new()); }
1941 }
1942 let (caps, r) = res!(roles(&mut s).await);
1943 let e = Entry { mailbox: "INBOX".into(), uid_validity: 100, uid: u, size: raw0.len() as u32,
1944 internal_date: "01-Jan-2025 09:00:00 +0000".into(), action: Action::Expunge, ..Default::default() };
1945 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
1946 eprintln!("X2 m4 {}: {:?} still_there={} sent={}", how, out, present(&s, "INBOX", &raw0), sent_any(&s));
1947 req!(false, sent_any(&s));
1948 }
1949 Ok(())
1950}
1951
1952/// M5: a second actor between the confirmation and the STORE: the message expunged and its UID
1953/// reused (a server breaking RFC 3501).
1954#[tokio::test]
1955async fn x2_m5_second_actor_before_store() -> Outcome<()> {
1956 let mut s = account(PLAIN);
1957 let u = s.deliver("INBOX", "a@x");
1958 s.on_store = Some(|s: &mut Server| {
1959 s.expunge("INBOX", 1);
1960 s.deliver_at("INBOX", 1, "other@x");
1961 });
1962 let (caps, r) = res!(roles(&mut s).await);
1963 let e = entry(u, "a@x", Action::Expunge);
1964 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
1965 eprintln!("X2 m5 u={} out={:?} other_kept={} log={:?}", u, out, s.has("INBOX", "other@x"), s.log);
1966 Ok(())
1967}
1968
1969/// M6: Unchanged only for equal bytes: a draft differing by line endings or a trailing newline
1970/// is saved; the same bytes at another UID than the old one is not Unchanged.
1971#[tokio::test]
1972async fn x2_m6_unchanged_neighbours() -> Outcome<()> {
1973 let base = draft("abcd");
1974 let lf: Vec<u8> = String::from_utf8_lossy(&base).replace("\r\n", "\n").into_bytes();
1975 let mut nl = base.clone();
1976 nl.extend_from_slice(b"\r\n");
1977 for (name, raw) in [("lf", lf), ("extra newline", nl)] {
1978 let mut s = drafts(PLAIN);
1979 let old = old_draft(&mut s, "Drafts", "abcd");
1980 let (caps, r) = res!(roles(&mut s).await);
1981 let out = res!(save_draft(&mut s, &caps, &r, &raw, Some(&old)).await);
1982 eprintln!("X2 m6 {}: {:?} n={} new_kept={}", name, out, s.folders["Drafts"].msgs.len(),
1983 present(&s, "Drafts", &raw));
1984 req!(true, present(&s, "Drafts", &raw) && out != Saved::Unchanged, "{}: {:?} {:?}", name, out, s.log);
1985 }
1986 // The same bytes under another UID (a cut earlier), the old version a different text.
1987 let mut s = drafts(PLAIN);
1988 let old = old_draft(&mut s, "Drafts", "abcd");
1989 s.put("Drafts", &draft("abce"), &["\\Draft"]);
1990 let (caps, r) = res!(roles(&mut s).await);
1991 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
1992 eprintln!("X2 m6 other uid: {:?} bodies={}", out, s.folders["Drafts"].msgs.len());
1993 req!(true, matches!(out, Saved::Replaced(_)) && bodies(&s, "Drafts") == vec![draft("abce")],
1994 "{:?} {:?}", out, s.log);
1995 Ok(())
1996}
1997
1998/// M6: the old version flagged \Deleted (a cut between STORE and EXPUNGE, or another client that
1999/// only marks), and the draft saved again with exactly its bytes; then a plain EXPUNGE elsewhere.
2000#[tokio::test]
2001async fn x2_m6_unchanged_on_a_deleted_old() -> Outcome<()> {
2002 let mut s = drafts(PLAIN);
2003 let old = old_draft(&mut s, "Drafts", "abcd");
2004 s.set_flags("Drafts", old.uid, &["\\Draft", "\\Deleted"]);
2005 s.put("Drafts", &draft("abce"), &["\\Draft"]);
2006 let (caps, r) = res!(roles(&mut s).await);
2007 let out = res!(save_draft(&mut s, &caps, &r, &draft("abcd"), Some(&old)).await);
2008 let del: Vec<u32> = s.folders["Drafts"].msgs.iter()
2009 .filter(|m| m.flags.iter().any(|f| f == "\\Deleted")).map(|m| m.uid).collect();
2010 for u in del {
2011 s.expunge("Drafts", u);
2012 }
2013 let kept = present(&s, "Drafts", &draft("abcd"));
2014 eprintln!("X2 m6_deleted_old out={:?} his_text_kept={} log={:?}", out, kept, s.log);
2015 req!(true, kept, "out {:?} log {:?}", out, s.log);
2016 Ok(())
2017}
2018
2019/// M2: a message with no Message-ID, confirmed by size and date, trashed on a server with UIDPLUS
2020/// and no MOVE, where a cut left the copy made: the retry copies again.
2021#[tokio::test]
2022async fn x2_m2_no_mid_copy_retry() -> Outcome<()> {
2023 let mut s = account("IMAP4rev1 UIDPLUS SPECIAL-USE");
2024 let raw0 = b"Subject: t\r\n\r\nno id\r\n".to_vec();
2025 let u = s.put("INBOX", &raw0, &[]);
2026 s.put("Trash", &raw0, &[]);
2027 let (caps, r) = res!(roles(&mut s).await);
2028 let e = Entry { mailbox: "INBOX".into(), uid_validity: 100, uid: u, size: raw0.len() as u32,
2029 internal_date: "01-Jan-2025 09:00:00 +0000".into(), action: Action::Trash, ..Default::default() };
2030 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
2031 let n = s.folders["Trash"].msgs.iter().filter(|m| m.raw == raw0).count();
2032 eprintln!("X2 m2_copy_retry out={:?} copies_in_trash={} log={:?}", out, n, s.log);
2033 req!(2, n, "{:?}", s.log); // ruled 15 Nov: a double, never a loss (was 1)
2034 Ok(())
2035}
2036
2037
2038// ┌───────────────────────────────────────────────────────────────────────────┐
2039// │ ROUND 2: A MAIL WITH NO MESSAGE-ID IS COPIED, NEVER FOUND: A DOUBLE, NO LOSS │
2040// └───────────────────────────────────────────────────────────────────────────┘
2041
2042const NO_MOVE: &str = "IMAP4rev1 UIDPLUS SPECIAL-USE";
2043
2044/// Without MOVE, a mail with no Message-ID is copied, never looked for in the target, then removed:
2045/// a mail there of its size and second (`unrelated`) is not taken for its copy, and a retry after a
2046/// cut between COPY and STORE leaves two copies (the accepted limit), never a loss.
2047async fn trash_without_move(unrelated: bool, cut: bool) -> Outcome<()> {
2048 let mut s = account(NO_MOVE);
2049 let raw0 = b"Subject: t\r\n\r\nno id\r\n".to_vec();
2050 let other = b"Subject: u\r\n\r\nno id\r\n".to_vec();
2051 let u = s.put("INBOX", &raw0, &[]);
2052 if unrelated {
2053 s.put("Trash", &other, &[]);
2054 }
2055 let (caps, r) = res!(roles(&mut s).await);
2056 let e = Entry { mailbox: "INBOX".into(), uid_validity: 100, uid: u, size: raw0.len() as u32,
2057 internal_date: "01-Jan-2025 09:00:00 +0000".into(), action: Action::Trash, ..Default::default() };
2058 s.cut_store = cut;
2059 if cut {
2060 req!(true, act(&mut s, &caps, &r, Provider::Steel, &e).await.is_err(), "{:?}", s.log);
2061 }
2062 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
2063 req!(ActOutcome::Done, out, "{:?}", s.log);
2064 req!(if cut { 2 } else { 1 }, s.folders["Trash"].msgs.iter().filter(|m| m.raw == raw0).count(), "{:?}", s.log);
2065 req!(unrelated, present(&s, "Trash", &other));
2066 req!(false, present(&s, "INBOX", &raw0), "{:?}", s.log);
2067 Ok(())
2068}
2069
2070#[tokio::test]
2071async fn test_no_message_id_trashed_without_move_00() -> Outcome<()> {
2072 trash_without_move(false, false).await
2073}
2074
2075#[tokio::test]
2076async fn test_no_message_id_cut_before_store_retried_00() -> Outcome<()> {
2077 trash_without_move(false, true).await
2078}
2079
2080#[tokio::test]
2081async fn test_no_message_id_copied_beside_a_lookalike_00() -> Outcome<()> {
2082 trash_without_move(true, false).await
2083}
2084
2085
2086// ┌───────────────────────────────────────────────────────────────────────────┐
2087// │ MAILfe-x3: THIRD EXAMINATION │
2088// └───────────────────────────────────────────────────────────────────────────┘
2089
2090use oxedyne_fe2o3_net::imap::types::parse_internal_date;
2091
2092fn x3_verbs() -> Vec<(Action, &'static str, Option<&'static str>)> {
2093 vec![
2094 (Action::Expunge, "INBOX", None),
2095 (Action::Trash, "INBOX", Some("Trash")),
2096 (Action::Junk, "INBOX", Some("Junk")),
2097 (Action::NotJunk, "Junk", Some("INBOX")),
2098 (Action::Archive, "INBOX", Some("Archive/2025")), // r3: Steel's yearly archive
2099 (Action::Move { to: Target::Path("Elsewhere".into()) }, "INBOX", Some("Elsewhere")),
2100 (Action::Move { to: Target::Role(SpecialUse::Trash) }, "INBOX", Some("Trash")),
2101 (Action::Flags { add: vec!["\\Seen".into()], remove: vec![] }, "INBOX", None),
2102 (Action::Flags { add: vec![], remove: vec!["\\Flagged".into()] }, "INBOX", None),
2103 ]
2104}
2105
2106/// R2: the third answer through every verb, with and without MOVE; and the mail that is gone.
2107#[tokio::test]
2108async fn x3_r2_every_verb_three_answers() -> Outcome<()> {
2109 let raw0 = b"Subject: t\r\n\r\nno id\r\n".to_vec();
2110 let mut bad = Vec::new();
2111 for caps in [PLAIN, NO_MOVE] {
2112 for (v, mb, dest) in x3_verbs() {
2113 for give in ["id other size", "other id", "date 1s", "date bad", "zone same", "gone id",
2114 "gone noid", "ok id", "ok noid"]
2115 {
2116 let mut s = account(caps);
2117 s.folder("Archive", "\\Archive", 600);
2118 let flags_only = matches!(v, Action::Flags { .. } | Action::Expunge);
2119 let noid = matches!(give, "date 1s" | "date bad" | "zone same" | "gone noid" | "ok noid");
2120 let (u, mut e) = if noid {
2121 let u = s.put(mb, &raw0, &["\\Flagged"]);
2122 (u, Entry { mailbox: mb.into(), uid_validity: s.folders[mb].uv, uid: u,
2123 size: raw0.len() as u32, internal_date: "01-Jan-2025 09:00:00 +0000".into(),
2124 action: v.clone(), year: Some(2025), ..Default::default() }) // r3: a year to archive by
2125 } else {
2126 let u = s.deliver(mb, "a@x");
2127 s.set_flags(mb, u, &["\\Flagged"]);
2128 let mut e = entry(u, "a@x", v.clone());
2129 e.mailbox = mb.into();
2130 e.uid_validity = s.folders[mb].uv;
2131 (u, e)
2132 };
2133 match give {
2134 "id other size" => e.size += 7,
2135 "other id" => { s.expunge(mb, u); s.deliver_at(mb, u, "other@x"); }
2136 "date 1s" => e.internal_date = "01-Jan-2025 09:00:01 +0000".into(),
2137 "date bad" => { s.dates.insert(u, "garbage".into()); e.internal_date = "garbage".into(); }
2138 "zone same" => { s.dates.insert(u, "01-Jan-2025 17:00:00 +0800".into()); }
2139 "gone id" | "gone noid" => s.expunge(mb, u),
2140 _ => {}
2141 }
2142 let (caps_, r) = res!(roles(&mut s).await);
2143 let out = res!(act(&mut s, &caps_, &r, Provider::Steel, &e).await);
2144 let sent = sent_any(&s);
2145 let in_src = s.folders[mb].msgs.iter().any(|m| m.uid == u);
2146 let in_dest = dest.map_or(0, |d| s.folders.get(d).map_or(0, |f| f.msgs.iter()
2147 .filter(|m| m.raw == raw0 || m.raw == raw("a@x", 2025)).count()));
2148 let stuck = |w: &str| matches!(&out, ActOutcome::Stuck(x) if x.contains(w));
2149 let ok = match give {
2150 "id other size" => stuck("its size differs") && !sent && in_src,
2151 "other id" => stuck("its Message-ID differs") && !sent && s.has(mb, "other@x"),
2152 "date 1s" => stuck("its date differs") && !sent && in_src,
2153 "date bad" => stuck("a date cannot be read") && !sent && in_src,
2154 "gone id" => !sent && if flags_only { out == ActOutcome::Gone } else { out == ActOutcome::Lost },
2155 "gone noid" => !sent && if flags_only { out == ActOutcome::Gone } else { stuck("has left") },
2156 _ => out == ActOutcome::Done && match (&v, dest) {
2157 (Action::Flags { .. }, _) => in_src,
2158 (_, None) => !in_src,
2159 (_, Some(_)) => !in_src && in_dest == 1,
2160 },
2161 };
2162 eprintln!("X3 R2 {:<8} {:?} {:<13} -> {:?} sent={} src={} dest={}", if caps == PLAIN { "MOVE" } else { "no MOVE" },
2163 v, give, out, sent, in_src, in_dest);
2164 if !ok {
2165 bad.push(fmt!("{} {:?} {}: {:?} sent={} src={} dest={} log={:?}", caps, v, give, out,
2166 sent, in_src, in_dest, s.log));
2167 }
2168 }
2169 }
2170 }
2171 req!(0, bad.len(), "{:#?}", bad);
2172 Ok(())
2173}
2174
2175/// R2: save_draft's third answer: OldLeft with a true reason, the old left, the new kept.
2176#[tokio::test]
2177async fn x3_r2_draft_three_answers() -> Outcome<()> {
2178 let raw0 = b"Subject: d\r\n\r\nno id\r\n".to_vec();
2179 let mut bad = Vec::new();
2180 for give in ["id other size", "other id", "date 1s", "gone", "ok"] {
2181 let mut s = drafts(PLAIN);
2182 let old = if give == "date 1s" {
2183 let u = s.put("Drafts", &raw0, &["\\Draft"]);
2184 Entry { mailbox: "Drafts".into(), uid_validity: 800, uid: u, size: raw0.len() as u32,
2185 internal_date: "01-Jan-2025 09:00:01 +0000".into(), ..Default::default() }
2186 } else {
2187 old_draft(&mut s, "Drafts", "abcd")
2188 };
2189 let mut old = old;
2190 match give {
2191 "id other size" => old.size += 7,
2192 "other id" => { s.expunge("Drafts", old.uid); s.deliver_at("Drafts", old.uid, "other@x"); }
2193 "gone" => s.expunge("Drafts", old.uid),
2194 _ => {}
2195 }
2196 let (caps, r) = res!(roles(&mut s).await);
2197 let out = res!(save_draft(&mut s, &caps, &r, &draft("abce"), Some(&old)).await);
2198 let old_there = s.folders["Drafts"].msgs.iter().any(|m| m.uid == old.uid);
2199 let new_kept = present(&s, "Drafts", &draft("abce"));
2200 let left = |w: &str| matches!(&out, Saved::OldLeft(_, x) if x.contains(w));
2201 let ok = new_kept && match give {
2202 "id other size" => left("its size differs") && old_there,
2203 "other id" => left("its Message-ID differs") && s.has("Drafts", "other@x"),
2204 "date 1s" => left("its date differs") && old_there,
2205 "gone" => matches!(out, Saved::OldGone(_)),
2206 _ => matches!(out, Saved::Replaced(_)) && !old_there,
2207 };
2208 eprintln!("X3 R2 draft {:<13} -> {:?} old_there={} new_kept={}", give, out, old_there, new_kept);
2209 if !ok {
2210 bad.push(fmt!("{}: {:?} {:?}", give, out, s.log));
2211 }
2212 }
2213 req!(0, bad.len(), "{:#?}", bad);
2214 Ok(())
2215}
2216
2217/// R3: the parser, case by case.
2218#[test]
2219fn x3_r3_parser() -> Outcome<()> {
2220 let p = |x: &str| parse_internal_date(x);
2221 let mut bad = Vec::new();
2222 let mut eq = |a: &str, b: &str, want: bool| {
2223 let got = p(a).is_some() && p(a) == p(b);
2224 eprintln!("X3 R3 {:?} vs {:?}: {:?} {:?} same={}", a, b, p(a), p(b), got);
2225 if got != want { bad.push(fmt!("{:?} vs {:?}: same={} wanted {}", a, b, got, want)); }
2226 };
2227 eq("17-Nov-2026 09:00:00 +0800", "17-Nov-2026 01:00:00 +0000", true);
2228 eq("17-Nov-2026 01:00:01 +0000", "17-Nov-2026 01:00:00 +0000", false);
2229 eq(" 7-Nov-2026 01:00:00 +0000", "07-Nov-2026 01:00:00 +0000", true);
2230 eq("7-Nov-2026 01:00:00 +0000", "07-Nov-2026 01:00:00 +0000", true);
2231 eq("17-Nov-2026 00:00:00 -0130", "17-Nov-2026 01:30:00 +0000", true);
2232 eq("17-Nov-2026 01:00:00", "17-Nov-2026 01:00:00 +0000", true);
2233 eq("17-nov-2026 01:00:00 +0000", "17-Nov-2026 01:00:00 +0000", true);
2234 eq("01-Jan-2017 00:00:00 +0000", "01-Jan-2017 00:00:00 +0000", true);
2235 eq("17-Nov-2026 01:00:00 +0000", "17-Nov-2026 01:00:00 +0001", false);
2236 eq("29-Feb-2024 01:00:00 +0000", "01-Mar-2024 01:00:00 +0000", false);
2237 // Shown, not judged: what the lenient forms read as.
2238 for x in ["17-Nov-26 01:00:00 +0000", "31-Dec-2016 23:59:60 +0000", "31-Feb-2026 01:00:00 +0000",
2239 "03-Mar-2026 01:00:00 +0000", "17-Nov-2026 01:00:00 +9959", "17-Nov-0 01:00:00 +0000",
2240 "01-Jan-1960 00:00:00 +0000", "17-Nov-2026 01:00:00 -0000"]
2241 {
2242 eprintln!("X3 R3 shown {:?}: {:?}", x, p(x));
2243 }
2244 eprintln!("X3 R3 leap 23:59:60 == next 00:00:00: {}", p("31-Dec-2016 23:59:60 +0000") == p("01-Jan-2017 00:00:00 +0000"));
2245 for x in ["", "garbage", "32-Nov-2026 01:00:00 +0000", "0-Nov-2026 01:00:00 +0000", "17-Foo-2026 01:00:00 +0000",
2246 "17-Nov-2026 24:00:00 +0000", "17-Nov-2026 01:60:00 +0000", "17-Nov-2026 01:00:61 +0000",
2247 "17-Nov-2026 01:00 +0000", "17-Nov-2026 01:00:00 +08:00", "17-Nov-2026 01:00:00 UTC",
2248 "17-Nov-2026 01:00:00 +0000 x", "17-Nov-2026 01:00:00 +0860", "17-Nov-2026 01:00:00 +08\u{e9}",
2249 "17-Nov-2026 01:00:00 0800", "-1-Nov-2026 01:00:00 +0000", "17-Nov-+2026 01:00:00 +0000",
2250 "17-Nov-2026 +1:00:00 +0000", "17-Nov-2026 01:00:00 ++800", "17-Nov-2026"]
2251 {
2252 eprintln!("X3 R3 none {:?}: {:?}", x, p(x));
2253 if p(x).is_some() { bad.push(fmt!("{:?} parsed to {:?}", x, p(x))); }
2254 }
2255 // A year past what the arithmetic holds: does it panic (debug) or answer?
2256 for x in ["17-Nov-999999999999 01:00:00 +0000", "17-Nov-9223372036854775807 01:00:00 +0000"] {
2257 let r = std::panic::catch_unwind(|| parse_internal_date(x));
2258 eprintln!("X3 R3 big year {:?}: {}", x, match &r { Ok(v) => fmt!("{:?}", v), Err(_) => "PANIC".into() });
2259 }
2260 req!(0, bad.len(), "{:#?}", bad);
2261 Ok(())
2262}
2263
2264/// R4: a mail WITH a Message-ID, trashed without MOVE, where Trash already holds ANOTHER message
2265/// of that Message-ID (an earlier draft version another client moved there, a list copy): is the
2266/// source copied before it is removed?
2267#[tokio::test]
2268async fn x3_r4_same_mid_other_bytes_in_target() -> Outcome<()> {
2269 let mut s = drafts(NO_MOVE);
2270 let last = draft("the last text");
2271 let u = s.put("Drafts", &last, &["\\Draft"]);
2272 s.put("Trash", &draft("an early text"), &["\\Draft"]);
2273 let (caps, r) = res!(roles(&mut s).await);
2274 let e = Entry { mailbox: "Drafts".into(), uid_validity: 800, uid: u, size: last.len() as u32,
2275 message_id: "<d@his.example>".into(), internal_date: "01-Jan-2025 09:00:00 +0000".into(),
2276 action: Action::Trash, ..Default::default() };
2277 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
2278 let kept = present(&s, "Trash", &last) || present(&s, "Drafts", &last);
2279 eprintln!("X3 R4 same mid: {:?} last_text_kept={} log={:?}", out, kept, s.log);
2280 req!(true, kept, "{:?} {:?}", out, s.log);
2281 Ok(())
2282}
2283
2284/// R4: no Message-ID, without MOVE: an IDENTICAL mail already in Trash (not a copy of this one):
2285/// the source is still copied; cut between COPY and STORE, retried: two, the source gone, Done.
2286#[tokio::test]
2287async fn x3_r4_no_mid_twin_and_cut() -> Outcome<()> {
2288 for cut in [false, true] {
2289 let mut s = account(NO_MOVE);
2290 let raw0 = b"Subject: t\r\n\r\nno id\r\n".to_vec();
2291 let u = s.put("INBOX", &raw0, &[]);
2292 s.put("Trash", &raw0, &[]);
2293 let (caps, r) = res!(roles(&mut s).await);
2294 let e = Entry { mailbox: "INBOX".into(), uid_validity: 100, uid: u, size: raw0.len() as u32,
2295 internal_date: "01-Jan-2025 09:00:00 +0000".into(), action: Action::Trash, ..Default::default() };
2296 s.cut_store = cut;
2297 let first = act(&mut s, &caps, &r, Provider::Steel, &e).await;
2298 let out = if cut { res!(act(&mut s, &caps, &r, Provider::Steel, &e).await) } else { res!(first) };
2299 let n = s.folders["Trash"].msgs.iter().filter(|m| m.raw == raw0).count();
2300 eprintln!("X3 R4 twin cut={}: {:?} in_trash={} src={}", cut, out, n, present(&s, "INBOX", &raw0));
2301 req!(ActOutcome::Done, out);
2302 req!(if cut { 3 } else { 2 }, n);
2303 req!(false, present(&s, "INBOX", &raw0));
2304 }
2305 Ok(())
2306}
2307
2308/// R5: the old version flagged \Deleted, the Flags FETCH answered with nothing (a garbled or cut
2309/// answer read as empty): is that taken as "not deleted", so Unchanged?
2310#[tokio::test]
2311async fn x3_r5_flags_unanswered_deleted_old() -> Outcome<()> {
2312 let mut s = drafts(PLAIN);
2313 let old = old_draft(&mut s, "Drafts", "abcd");
2314 s.set_flags("Drafts", old.uid, &["\\Draft", "\\Deleted"]);
2315 s.flags_none = true;
2316 let (caps, r) = res!(roles(&mut s).await);
2317 let out = res!(save_draft(&mut s, &caps, &r, &draft("abcd"), Some(&old)).await);
2318 s.expunge("Drafts", old.uid);
2319 let kept = present(&s, "Drafts", &draft("abcd"));
2320 eprintln!("X3 R5 flags unanswered: {:?} text_kept_after_expunge={}", out, kept);
2321 req!(true, kept, "{:?} {:?}", out, s.log);
2322 Ok(())
2323}
2324
2325/// R5: the plain three: equal not flagged (Unchanged, nothing sent), flagged (saved anew),
2326/// a trailing newline (saved).
2327#[tokio::test]
2328async fn x3_r5_unchanged_three() -> Outcome<()> {
2329 for (name, flag, text) in [("equal", false, "abcd"), ("flagged", true, "abcd"), ("newline", false, "abcd\r\n")] {
2330 let mut s = drafts(PLAIN);
2331 let old = old_draft(&mut s, "Drafts", "abcd");
2332 if flag {
2333 s.set_flags("Drafts", old.uid, &["\\Draft", "\\Deleted"]);
2334 }
2335 let (caps, r) = res!(roles(&mut s).await);
2336 let out = res!(save_draft(&mut s, &caps, &r, &draft(text), Some(&old)).await);
2337 let n = s.folders["Drafts"].msgs.len();
2338 let appended = s.log.iter().any(|l| l.starts_with("APPEND"));
2339 eprintln!("X3 R5 {}: {:?} n={} appended={} log={:?}", name, out, n, appended, s.log);
2340 match name {
2341 "equal" => { req!(Saved::Unchanged, out); req!(false, appended || sent_any(&s)); }
2342 _ => { req!(true, matches!(out, Saved::Replaced(_)), "{:?}", out);
2343 req!(true, present(&s, "Drafts", &draft(text))); req!(1, n); }
2344 }
2345 }
2346 Ok(())
2347}
2348
2349
2350// ┌───────────────────────────────────────────────────────────────────────────┐
2351// │ ROUND 3: ONE RULE OF SAMENESS, A LOOK-ALIKE BY MESSAGE-ID ALONE IN EACH PLACE │
2352// └───────────────────────────────────────────────────────────────────────────┘
2353
2354const DAY2: &str = "02-Jan-2025 09:00:00 +0000";
2355
2356/// `resolve`, the UID unchanged: the entry's Message-ID and size, another INTERNALDATE.
2357#[tokio::test]
2358async fn test_one_rule_resolve_lookalike_00() -> Outcome<()> {
2359 let mut s = account(PLAIN);
2360 let u = s.deliver("INBOX", "a@x");
2361 s.dates.insert(u, DAY2.into());
2362 let (caps, r) = res!(roles(&mut s).await);
2363 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Expunge)).await);
2364 req!(true, matches!(&out, ActOutcome::Stuck(w) if w.contains("date differs")), "{:?}", out);
2365 req!(true, s.has("INBOX", "a@x"));
2366 Ok(())
2367}
2368
2369/// `resolve`, the folder renumbered: one match by Message-ID and size, of another INTERNALDATE.
2370#[tokio::test]
2371async fn test_one_rule_renumbered_lookalike_00() -> Outcome<()> {
2372 let mut s = account(PLAIN);
2373 let u = s.deliver("INBOX", "a@x");
2374 s.renumber("INBOX", 777);
2375 let nu = s.folders["INBOX"].msgs[0].uid;
2376 s.dates.insert(nu, DAY2.into());
2377 let (caps, r) = res!(roles(&mut s).await);
2378 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Expunge)).await);
2379 req!(true, matches!(out, ActOutcome::Stuck(_)), "{:?}", out);
2380 req!(true, s.has("INBOX", "a@x"));
2381 Ok(())
2382}
2383
2384/// `locate`: the source gone, Trash holds another message of its Message-ID: not its move.
2385#[tokio::test]
2386async fn test_one_rule_locate_lookalike_00() -> Outcome<()> {
2387 let mut s = account(PLAIN);
2388 let u = s.deliver("INBOX", "a@x");
2389 s.expunge("INBOX", u);
2390 s.put("Trash", b"Message-ID: <a@x>\r\nSubject: list copy\r\n\r\nother\r\n", &[]);
2391 let (caps, r) = res!(roles(&mut s).await);
2392 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Trash)).await);
2393 req!(ActOutcome::Lost, out);
2394 Ok(())
2395}
2396
2397/// `save_draft`'s `Unchanged`: the bytes at the old UID, the old entry's INTERNALDATE another.
2398#[tokio::test]
2399async fn test_one_rule_unchanged_lookalike_00() -> Outcome<()> {
2400 let mut s = drafts(PLAIN);
2401 let mut old = old_draft(&mut s, "Drafts", "abcd");
2402 old.internal_date = DAY2.into();
2403 let (caps, r) = res!(roles(&mut s).await);
2404 let out = res!(save_draft(&mut s, &caps, &r, &draft("abcd"), Some(&old)).await);
2405 req!(true, matches!(&out, Saved::OldLeft(_, w) if w.contains("date differs")), "{:?}", out);
2406 req!(true, present(&s, "Drafts", &draft("abcd")));
2407 Ok(())
2408}
2409
2410/// `file_sent`: Sent holds another message of the sent one's Message-ID: the copy is appended.
2411#[tokio::test]
2412async fn test_one_rule_sent_copy_lookalike_00() -> Outcome<()> {
2413 let mut s = account(PLAIN);
2414 s.put("Sent", b"Message-ID: <s@x>\r\nSubject: an earlier send\r\n\r\nx\r\n", &["\\Seen"]);
2415 let (_, r) = res!(roles(&mut s).await);
2416 let filed = res!(file_sent(&mut s, &r, Provider::Steel, "<s@x>", &raw("s@x", 2025)).await);
2417 req!(true, matches!(filed, Filed::Appended(_)), "{:?}", filed);
2418 req!(true, present(&s, "Sent", &raw("s@x", 2025)));
2419 Ok(())
2420}
2421
2422/// The INTERNALDATE parser takes the grammar's four-digit year, and a long one neither panics
2423/// nor wraps.
2424#[test]
2425fn test_internal_date_year_is_four_digits_00() -> Outcome<()> {
2426 for x in ["17-Nov-26 01:00:00 +0000", "17-Nov-999999999999 01:00:00 +0000",
2427 "17-Nov-9223372036854775807 01:00:00 +0000", "17-Nov-02026 01:00:00 +0000"]
2428 {
2429 let got = std::panic::catch_unwind(|| parse_internal_date(x));
2430 req!(true, matches!(got, Ok(None)), "{:?}: {:?}", x, got);
2431 }
2432 req!(true, parse_internal_date("17-Nov-2026 01:00:00 +0000").is_some());
2433 Ok(())
2434}
2435
2436
2437// ┌───────────────────────────────────────────────────────────────────────────┐
2438// │ MAILfe-x4: FOURTH EXAMINATION, ROWS S2 TO S5 │
2439// └───────────────────────────────────────────────────────────────────────────┘
2440
2441thread_local! {
2442 // x4: the BODY.PEEK[] answer for this UID is cut by one byte (Some((uid, true))) or garbled.
2443 static X4_SECTION: std::cell::Cell<Option<(u32, bool)>> = const { std::cell::Cell::new(None) };
2444}
2445
2446const X4_DAY2: &str = "02-Jan-2025 09:00:00 +0000";
2447
2448/// The look-alikes of `raw("a@x", 2025)`: by Message-ID alone; Message-ID and size, another date;
2449/// all three, other bytes.
2450fn x4_look(kind: &str) -> (Vec<u8>, bool) {
2451 let real = raw("a@x", 2025);
2452 match kind {
2453 "alone" => (b"Message-ID: <a@x>\r\nSubject: list copy\r\n\r\nother\r\n".to_vec(), true),
2454 "mid_size" => {
2455 let v = fmt!("{}", String::from_utf8_lossy(&real)).replace("body of a@x", "body of a@y").into_bytes();
2456 assert_eq!(v.len(), real.len());
2457 (v, true)
2458 }
2459 _ => {
2460 let v = fmt!("{}", String::from_utf8_lossy(&real)).replace("body of a@x", "body of a@z").into_bytes();
2461 (v, false)
2462 }
2463 }
2464}
2465
2466/// S2: in each place, the three look-alikes; what each answers and whether anything is lost.
2467#[tokio::test]
2468async fn x4_s2_every_place() -> Outcome<()> {
2469 let real = raw("a@x", 2025);
2470 let mut bad = Vec::new();
2471 for kind in ["alone", "mid_size", "all3"] {
2472 let (look, dated) = x4_look(kind);
2473 // P1 resolve, the UID unchanged.
2474 let mut s = account(PLAIN);
2475 let u = s.put("INBOX", &look, &[]);
2476 if dated { s.dates.insert(u, X4_DAY2.into()); }
2477 let (caps, r) = res!(roles(&mut s).await);
2478 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Expunge)).await);
2479 let kept = present(&s, "INBOX", &look);
2480 eprintln!("X4 S2 P1 resolve {}: {:?} look_kept={}", kind, out, kept);
2481 if !kept && kind != "all3" { bad.push(fmt!("P1 {}", kind)); }
2482 // P2 resolve, renumbered.
2483 let mut s = account(PLAIN);
2484 let u = s.put("INBOX", &look, &[]);
2485 s.renumber("INBOX", 777);
2486 let nu = s.folders["INBOX"].msgs[0].uid;
2487 if dated { s.dates.insert(nu, X4_DAY2.into()); }
2488 let (caps, r) = res!(roles(&mut s).await);
2489 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Trash)).await);
2490 let kept = present(&s, "INBOX", &look);
2491 eprintln!("X4 S2 P2 renumbered {}: {:?} look_in_inbox={}", kind, out, kept);
2492 if !kept && kind != "all3" { bad.push(fmt!("P2 {}", kind)); }
2493 // P3 locate, the target; P4 locate, another folder.
2494 for mb in ["Trash", "Elsewhere"] {
2495 let mut s = account(PLAIN);
2496 s.deliver("INBOX", "filler@x");
2497 let u = s.deliver("INBOX", "a@x");
2498 s.expunge("INBOX", u);
2499 let l = s.put(mb, &look, &[]);
2500 if dated { s.dates.insert(l, X4_DAY2.into()); }
2501 let (caps, r) = res!(roles(&mut s).await);
2502 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Trash)).await);
2503 eprintln!("X4 S2 locate {} {}: {:?}", mb, kind, out);
2504 if out != ActOutcome::Lost && kind != "all3" { bad.push(fmt!("locate {} {}: {:?}", mb, kind, out)); }
2505 }
2506 // P5 held_in: without MOVE, Trash holds the look-alike; the real mail must reach Trash.
2507 let mut s = account(NO_MOVE);
2508 s.deliver("INBOX", "filler@x");
2509 let u = s.deliver("INBOX", "a@x");
2510 let l = s.put("Trash", &look, &[]);
2511 if dated { s.dates.insert(l, X4_DAY2.into()); }
2512 let (caps, r) = res!(roles(&mut s).await);
2513 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Trash)).await);
2514 let kept = present(&s, "Trash", &real) || present(&s, "INBOX", &real);
2515 eprintln!("X4 S2 P5 held_in {}: {:?} real_kept={} look_kept={}", kind, out, kept, present(&s, "Trash", &look));
2516 if !kept { bad.push(fmt!("P5 held_in {}: real lost", kind)); }
2517 // P6 file_sent: Sent holds the look-alike.
2518 let mut s = account(PLAIN);
2519 let l = s.put("Sent", &look, &["\\Seen"]);
2520 if dated { s.dates.insert(l, X4_DAY2.into()); }
2521 let (_, r) = res!(roles(&mut s).await);
2522 let filed = res!(file_sent(&mut s, &r, Provider::Steel, "<a@x>", &real).await);
2523 let there = present(&s, "Sent", &real);
2524 eprintln!("X4 S2 P6 file_sent {}: {:?} real_in_sent={}", kind, filed, there);
2525 if !there { bad.push(fmt!("P6 file_sent {}: {:?}, the sent mail not in Sent", kind, filed)); }
2526 // P7 save_draft: the old entry's UID holds a look-alike of the old version.
2527 let mut s = drafts(PLAIN);
2528 let old_raw = draft("old text");
2529 let lk = match kind {
2530 "alone" => draft("an unrelated, longer text"),
2531 _ => draft("odd text"),
2532 };
2533 let lu = s.put("Drafts", &lk, &["\\Draft"]);
2534 if dated { s.dates.insert(lu, X4_DAY2.into()); }
2535 let old = Entry { mailbox: "Drafts".into(), uid_validity: 800, uid: lu, size: old_raw.len() as u32,
2536 message_id: "<d@his.example>".into(), internal_date: "01-Jan-2025 09:00:00 +0000".into(),
2537 ..Default::default() };
2538 let (caps, r) = res!(roles(&mut s).await);
2539 let out = res!(save_draft(&mut s, &caps, &r, &draft("new text"), Some(&old)).await);
2540 let kept = present(&s, "Drafts", &lk) && present(&s, "Drafts", &draft("new text"));
2541 eprintln!("X4 S2 P7 save_draft {}: {:?} look_and_new_kept={}", kind, out, kept);
2542 if !kept && kind != "all3" { bad.push(fmt!("P7 save_draft {}: {:?}", kind, out)); }
2543 }
2544 eprintln!("X4 S2 BAD: {:?}", bad);
2545 req!(true, bad.is_empty(), "{:?}", bad);
2546 Ok(())
2547}
2548
2549/// S2: an entry with a Message-ID and neither size nor date (the page's older form): the folder
2550/// renumbered and Drafts holding only ANOTHER version of the draft.
2551#[tokio::test]
2552async fn x4_s2_sizeless_entry_other_version() -> Outcome<()> {
2553 let mut s = drafts(PLAIN);
2554 let a = s.put("Drafts", &draft("version A"), &["\\Draft"]);
2555 s.expunge("Drafts", a);
2556 s.put("Drafts", &draft("version B, the last text"), &["\\Draft"]);
2557 s.renumber("Drafts", 801);
2558 let (caps, r) = res!(roles(&mut s).await);
2559 let e = Entry { mailbox: "Drafts".into(), uid_validity: 800, uid: a,
2560 message_id: "<d@his.example>".into(), action: Action::Expunge, ..Default::default() };
2561 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
2562 let kept = present(&s, "Drafts", &draft("version B, the last text"));
2563 eprintln!("X4 S2 sizeless renumbered: {:?} B_kept={}", out, kept);
2564 // The same entry, the UID unchanged and holding version B (a server that reuses UIDs).
2565 let mut s = drafts(PLAIN);
2566 s.put("Drafts", &draft("version B, the last text"), &["\\Draft"]);
2567 let (caps, r) = res!(roles(&mut s).await);
2568 let e = Entry { mailbox: "Drafts".into(), uid_validity: 800, uid: 1,
2569 message_id: "<d@his.example>".into(), action: Action::Expunge, ..Default::default() };
2570 let out2 = res!(act(&mut s, &caps, &r, Provider::Steel, &e).await);
2571 let kept2 = present(&s, "Drafts", &draft("version B, the last text"));
2572 eprintln!("X4 S2 sizeless same uid: {:?} B_kept={}", out2, kept2);
2573 req!(true, kept && kept2, "{:?} {:?}", out, out2);
2574 Ok(())
2575}
2576
2577/// S3: held_in's byte compare: a candidate differing only in line endings; the source's or the
2578/// candidate's fetch cut or garbled; then the verb. The real mail must be in Trash, the source gone.
2579#[tokio::test]
2580async fn x4_s3_held_in_compare() -> Outcome<()> {
2581 let real = raw("a@x", 2025);
2582 let mut bad = Vec::new();
2583 for (name, cand, hook) in [
2584 ("lf_endings", Some(String::from_utf8_lossy(&real).replace("a@x\r\n\r\nbody of a@x\r\n", "a@x\r\n\r\nbody of a@x\n").into_bytes()), None),
2585 ("src_cut", None, Some((true, true))),
2586 ("src_garbled", None, Some((true, false))),
2587 ("cand_true_garbled", Some(real.clone()), Some((false, false))),
2588 ("cand_true_cut", Some(real.clone()), Some((false, true))),
2589 ("cand_true", Some(real.clone()), None),
2590 ] {
2591 let mut s = account(NO_MOVE);
2592 for _ in 0..5 { s.deliver("INBOX", "filler@x"); }
2593 let u = s.deliver("INBOX", "a@x");
2594 let c = cand.as_ref().map(|c| s.put("Trash", c, &[]));
2595 X4_SECTION.with(|x| x.set(hook.map(|(src, cut)| (if src { u } else { c.unwrap_or(0) }, cut))));
2596 let (caps, r) = res!(roles(&mut s).await);
2597 let out = res!(act(&mut s, &caps, &r, Provider::Steel, &entry(u, "a@x", Action::Trash)).await);
2598 X4_SECTION.with(|x| x.set(None));
2599 let n = s.folders["Trash"].msgs.iter().filter(|m| m.raw == real).count();
2600 let src = present(&s, "INBOX", &real);
2601 let copies = s.log.iter().filter(|l| l.starts_with("UID COPY") || l.contains("COPY")).count();
2602 eprintln!("X4 S3 {}: {:?} real_in_trash={} src_left={} copy_lines={}", name, out, n, src, copies);
2603 if n == 0 && !src { bad.push(fmt!("{}: LOST", name)); }
2604 if n == 0 { bad.push(fmt!("{}: not trashed", name)); }
2605 }
2606 eprintln!("X4 S3 BAD: {:?}", bad);
2607 req!(true, bad.is_empty(), "{:?}", bad);
2608 Ok(())
2609}
2610
2611/// S5: the Flags answer in save_draft: absent (none for the UID) and empty (FLAGS ()), the old
2612/// version these very bytes and not flagged.
2613#[tokio::test]
2614async fn x4_s5_flags_absent_and_empty() -> Outcome<()> {
2615 for absent in [true, false] {
2616 let mut s = drafts(PLAIN);
2617 let old = old_draft(&mut s, "Drafts", "same text");
2618 s.set_flags("Drafts", old.uid, &[]);
2619 s.flags_none = absent;
2620 let (caps, r) = res!(roles(&mut s).await);
2621 let out = res!(save_draft(&mut s, &caps, &r, &draft("same text"), Some(&old)).await);
2622 let n = s.folders["Drafts"].msgs.iter().filter(|m| m.raw == draft("same text")).count();
2623 eprintln!("X4 S5 flags absent={}: {:?} copies={}", absent, out, n);
2624 req!(true, n >= 1);
2625 }
2626 Ok(())
2627}
2628
2629/// S5: years of 2, 3, 5 and 12 digits (and 4 for contrast), in a debug build.
2630#[test]
2631fn x4_s5_year_digits() -> Outcome<()> {
2632 for y in ["26", "202", "2026", "02026", "20260", "999999999999"] {
2633 let x = fmt!("17-Nov-{} 01:00:00 +0000", y);
2634 let got = std::panic::catch_unwind(|| parse_internal_date(&x));
2635 eprintln!("X4 S5 year {:?}: {:?}", y, got);
2636 req!(true, got.is_ok(), "{}: panic", x);
2637 let four = y.len() == 4;
2638 req!(four, matches!(got, Ok(Some(_))), "{}: {:?}", x, got);
2639 }
2640 Ok(())
2641}
2642
2643/// `file_sent`: Sent holds a message of the sent one's Message-ID and size, other bytes: not its
2644/// copy, so the copy is appended beside it.
2645#[tokio::test]
2646async fn test_sent_copy_confirmed_by_bytes_00() -> Outcome<()> {
2647 let mut s = account(PLAIN);
2648 let sent = raw("s@x", 2025);
2649 let mut other = sent.clone();
2650 let n = other.len();
2651 other[n - 3] ^= 0x20;
2652 s.put("Sent", &other, &["\\Seen"]);
2653 let (_, r) = res!(roles(&mut s).await);
2654 let filed = res!(file_sent(&mut s, &r, Provider::Steel, "<s@x>", &sent).await);
2655 req!(true, matches!(filed, Filed::Appended(_)), "{:?}", filed);
2656 req!(true, present(&s, "Sent", &sent));
2657 Ok(())
2658}