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 | |
| 7 | use oxedyne_fe2o3_core::prelude::*; |
| 8 | use 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 | |
| 49 | use std::collections::BTreeMap; |
| 50 | |
| 51 | |
| 52 | // ┌───────────────────────────────────────────────────────────────────────────┐ |
| 53 | // │ THE SCRIPTED SERVER │ |
| 54 | // └───────────────────────────────────────────────────────────────────────────┘ |
| 55 | |
| 56 | #[derive(Clone, Debug)] |
| 57 | struct 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)] |
| 66 | struct 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)] |
| 76 | struct 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)] |
| 95 | enum 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 | |
| 104 | fn 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 | |
| 109 | impl 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 | |
| 266 | impl 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)] |
| 471 | struct Gen { |
| 472 | uv: u32, |
| 473 | msgs: BTreeMap<String, Vec<u8>>, // Maildir name to bytes |
| 474 | } |
| 475 | |
| 476 | #[derive(Clone, Debug, Default, PartialEq)] |
| 477 | struct Held { |
| 478 | gen: Option<Gen>, |
| 479 | aside: Option<Gen>, |
| 480 | cursor: Option<Cursor>, |
| 481 | } |
| 482 | |
| 483 | #[derive(Default)] |
| 484 | struct Store { |
| 485 | folders: BTreeMap<String, Held>, |
| 486 | fail_put: bool, |
| 487 | } |
| 488 | |
| 489 | impl 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 | |
| 524 | impl 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. |
| 591 | async 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 | |
| 598 | const QRESYNC: &str = "IMAP4rev1 CONDSTORE QRESYNC MOVE UIDPLUS SPECIAL-USE"; |
| 599 | const CONDSTORE: &str = "IMAP4rev1 CONDSTORE MOVE UIDPLUS SPECIAL-USE X-GM-EXT-1"; |
| 600 | const 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. |
| 609 | async 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] |
| 627 | async 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] |
| 640 | async 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] |
| 652 | async 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] |
| 664 | async 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] |
| 691 | async 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] |
| 718 | async 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] |
| 758 | async 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] |
| 801 | async 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] |
| 826 | async 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] |
| 859 | async 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] |
| 879 | async 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 | |
| 923 | fn 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 | |
| 932 | async 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 | |
| 939 | fn 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] |
| 948 | async 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] |
| 960 | async 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] |
| 976 | async 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] |
| 996 | async 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] |
| 1022 | async 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] |
| 1041 | async 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] |
| 1055 | async 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] |
| 1070 | async 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] |
| 1086 | async 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] |
| 1103 | async 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] |
| 1128 | async 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] |
| 1147 | fn 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] |
| 1165 | fn 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] |
| 1186 | async 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] |
| 1201 | async 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] |
| 1224 | async 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] |
| 1240 | async 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] |
| 1262 | async 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] |
| 1280 | async 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] |
| 1320 | async 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] |
| 1340 | async 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] |
| 1364 | async 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] |
| 1381 | fn 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] |
| 1399 | async 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] |
| 1428 | async 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 | |
| 1447 | fn drafts(caps: &str) -> Server { |
| 1448 | let mut s = account(caps); |
| 1449 | s.folder("Drafts", "\\Drafts", 800); |
| 1450 | s |
| 1451 | } |
| 1452 | |
| 1453 | fn 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. |
| 1458 | fn 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 | |
| 1467 | fn 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] |
| 1474 | async 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] |
| 1495 | async 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] |
| 1514 | async 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] |
| 1532 | async 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] |
| 1552 | async 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] |
| 1587 | async 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] |
| 1610 | async 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] |
| 1639 | async 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] |
| 1657 | async 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] |
| 1679 | async 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] |
| 1700 | async 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] |
| 1714 | async 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] |
| 1746 | async 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] |
| 1766 | async 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] |
| 1791 | async 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 | |
| 1811 | fn present(s: &Server, mb: &str, raw: &[u8]) -> bool { |
| 1812 | s.folders[mb].msgs.iter().any(|m| m.raw == raw) |
| 1813 | } |
| 1814 | |
| 1815 | fn 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] |
| 1823 | async 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] |
| 1840 | async 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] |
| 1859 | async 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] |
| 1878 | async 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] |
| 1912 | async 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] |
| 1933 | async 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] |
| 1955 | async 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] |
| 1972 | async 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] |
| 2001 | async 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] |
| 2022 | async 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 | |
| 2042 | const 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. |
| 2047 | async 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] |
| 2071 | async fn test_no_message_id_trashed_without_move_00() -> Outcome<()> { |
| 2072 | trash_without_move(false, false).await |
| 2073 | } |
| 2074 | |
| 2075 | #[tokio::test] |
| 2076 | async fn test_no_message_id_cut_before_store_retried_00() -> Outcome<()> { |
| 2077 | trash_without_move(false, true).await |
| 2078 | } |
| 2079 | |
| 2080 | #[tokio::test] |
| 2081 | async 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 | |
| 2090 | use oxedyne_fe2o3_net::imap::types::parse_internal_date; |
| 2091 | |
| 2092 | fn 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] |
| 2108 | async 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] |
| 2177 | async 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] |
| 2219 | fn 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] |
| 2268 | async 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] |
| 2287 | async 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] |
| 2311 | async 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] |
| 2328 | async 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 | |
| 2354 | const 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] |
| 2358 | async 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] |
| 2371 | async 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] |
| 2386 | async 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] |
| 2399 | async 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] |
| 2412 | async 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] |
| 2425 | fn 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 | |
| 2441 | thread_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 | |
| 2446 | const 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. |
| 2450 | fn 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] |
| 2468 | async 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] |
| 2552 | async 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] |
| 2580 | async 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] |
| 2614 | async 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] |
| 2631 | fn 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] |
| 2646 | async 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 | } |