tests/behavior.rs

@@ -2,6 +2,7 @@ use anyhow::Context;
 
 mod common;
 use crate::common::fragments::*;
+use crate::common::constants::*;
 
 fn main() {
     rfc3501_imap4rev1_base();
@@ -22,20 +23,25 @@ fn rfc3501_imap4rev1_base() {
         create_mailbox(imap_socket, Mailbox::Archive).context("created mailbox archive")?;
         // UNSUBSCRIBE IS NOT IMPLEMENTED YET
         //unsubscribe_mailbox(imap_socket).context("unsubscribe from archive")?;
-        select(imap_socket, Mailbox::Inbox, SelectMod::None, None).context("select inbox")?;
+        let select_res = select(imap_socket, Mailbox::Inbox, SelectMod::None).context("select inbox")?;
+        assert!(select_res.contains("* 0 EXISTS"));
+
         check(imap_socket).context("check must run")?;
-        status_mailbox(imap_socket, Mailbox::Archive).context("status of archive from inbox")?;
+        status(imap_socket, Mailbox::Archive, StatusKind::UidNext).context("status of archive from inbox")?;
         lmtp_handshake(lmtp_socket).context("handshake lmtp done")?;
         lmtp_deliver_email(lmtp_socket, Email::Multipart).context("mail delivered successfully")?;
         noop_exists(imap_socket, 1).context("noop loop must detect a new email")?;
-        fetch_rfc822(imap_socket, Selection::FirstId, Email::Multipart)
+
+        let srv_msg = fetch(imap_socket, Selection::FirstId, FetchKind::Rfc822, FetchMod::None)
             .context("fetch rfc822 message, should be our first message")?;
+        let orig_email = std::str::from_utf8(EMAIL1)?;
+        assert!(srv_msg.contains(orig_email));
+        
         copy(imap_socket, Selection::FirstId, Mailbox::Archive)
             .context("copy message to the archive mailbox")?;
         append_email(imap_socket, Email::Basic).context("insert email in INBOX")?;
         noop_exists(imap_socket, 2).context("noop loop must detect a new email")?;
-        // Missing STORE command
+        search(imap_socket, SearchKind::Text("OoOoO")).expect("search should return something");
-        search(imap_socket).expect("search should return something");
         store(imap_socket, Selection::FirstId, Flag::Deleted, StoreAction::AddFlags, StoreMod::None)
             .context("should add delete flag to the email")?;
         expunge(imap_socket).context("expunge emails")?;
@@ -57,18 +63,26 @@ fn rfc3691_imapext_unselect() {
 
         capability(imap_socket, Extension::Unselect).context("check server capabilities")?;
         login(imap_socket, Account::Alice).context("login test")?;
-        select(imap_socket, Mailbox::Inbox, SelectMod::None, None).context("select inbox")?;
+        let select_res = select(imap_socket, Mailbox::Inbox, SelectMod::None).context("select inbox")?;
+        assert!(select_res.contains("* 0 EXISTS"));
+
         noop_exists(imap_socket, 1).context("noop loop must detect a new email")?;
         store(imap_socket, Selection::FirstId, Flag::Deleted, StoreAction::AddFlags, StoreMod::None)
             .context("add delete flags to the email")?;
         unselect(imap_socket)
             .context("unselect inbox while preserving email with the \\Delete flag")?;
-        select(imap_socket, Mailbox::Inbox, SelectMod::None, Some(1)).context("select inbox again")?;
+        let select_res = select(imap_socket, Mailbox::Inbox, SelectMod::None).context("select inbox again")?;
-        fetch_rfc822(imap_socket, Selection::FirstId, Email::Basic)
+        assert!(select_res.contains("* 1 EXISTS"));
+
+        let srv_msg = fetch(imap_socket, Selection::FirstId, FetchKind::Rfc822, FetchMod::None)
             .context("message is still present")?;
+        let orig_email = std::str::from_utf8(EMAIL2)?;
+        assert!(srv_msg.contains(orig_email));
+
         close(imap_socket).context("close inbox and expunge message")?;
-        select(imap_socket, Mailbox::Inbox, SelectMod::None, Some(0))
+        let select_res = select(imap_socket, Mailbox::Inbox, SelectMod::None)
             .context("select inbox again and check it's empty")?;
+        assert!(select_res.contains("* 0 EXISTS"));
 
         Ok(())
     })
@@ -97,7 +111,8 @@ fn rfc6851_imapext_move() {
         capability(imap_socket, Extension::Move).context("check server capabilities")?;
         login(imap_socket, Account::Alice).context("login test")?;
         create_mailbox(imap_socket, Mailbox::Archive).context("created mailbox archive")?;
-        select(imap_socket, Mailbox::Inbox, SelectMod::None, None).context("select inbox")?;
+        let select_res = select(imap_socket, Mailbox::Inbox, SelectMod::None).context("select inbox")?;
+        assert!(select_res.contains("* 0 EXISTS"));
 
         lmtp_handshake(lmtp_socket).context("handshake lmtp done")?;
         lmtp_deliver_email(lmtp_socket, Email::Basic).context("mail delivered successfully")?;
@@ -108,8 +123,18 @@ fn rfc6851_imapext_move() {
 
         unselect(imap_socket)
             .context("unselect inbox while preserving email with the \\Delete flag")?;
-        select(imap_socket, Mailbox::Archive, SelectMod::None, Some(1)).context("select archive")?;
+        let select_res = select(imap_socket, Mailbox::Archive, SelectMod::None).context("select archive")?;
-        fetch_rfc822(imap_socket, Selection::FirstId, Email::Basic).context("check mail exists")?;
+        assert!(select_res.contains("* 1 EXISTS"));
+
+        let srv_msg = fetch(
+            imap_socket, 
+            Selection::FirstId, 
+            FetchKind::Rfc822, 
+            FetchMod::None,
+        ).context("check mail exists")?;
+        let orig_email = std::str::from_utf8(EMAIL2)?;
+        assert!(srv_msg.contains(orig_email));
+
         logout(imap_socket).context("must quit")?;
 
         Ok(())
@@ -135,21 +160,41 @@ fn rfc4551_imapext_condstore() {
     common::aerogramme_provider_daemon_dev(|imap_socket, lmtp_socket| {
         // Setup the test
         connect(imap_socket).context("server says hello")?;
+
+        // RFC 3.1.1 Advertising Support for CONDSTORE
         capability(imap_socket, Extension::Condstore).context("check server capabilities")?;
         login(imap_socket, Account::Alice).context("login test")?;
 
-        // Check that the condstore modifier works
+        // RFC 3.1.8.  CONDSTORE Parameter to SELECT and EXAMINE
-        select(imap_socket, Mailbox::Inbox, SelectMod::Condstore, None).context("select inbox")?;
+        let select_res = select(imap_socket, Mailbox::Inbox, SelectMod::Condstore).context("select inbox")?;
-
+        // RFC 3.1.2   New OK Untagged Responses for SELECT and EXAMINE
+        assert!(select_res.contains("[HIGHESTMODSEQ 1]"));
 
+        // RFC 3.1.3.  STORE and UID STORE Commands
         lmtp_handshake(lmtp_socket).context("handshake lmtp done")?;
         lmtp_deliver_email(lmtp_socket, Email::Basic).context("mail delivered successfully")?;
         lmtp_deliver_email(lmtp_socket, Email::Multipart).context("mail delivered successfully")?;
         noop_exists(imap_socket, 2).context("noop loop must detect a new email")?;
+        let store_res = store(imap_socket, Selection::All, Flag::Important, StoreAction::AddFlags, StoreMod::UnchangedSince(1))?;
+        assert!(store_res.contains("[MODIFIED 2]"));
+        assert!(store_res.contains("* 1 FETCH (FLAGS (\\Important) MODSEQ (3))"));
+        assert!(!store_res.contains("* 2 FETCH"));
+        assert_eq!(store_res.lines().count(), 2);
 
+        // RFC 3.1.4.  FETCH and UID FETCH Commands
+        let fetch_res = fetch(imap_socket, Selection::All, FetchKind::Rfc822Size, FetchMod::ChangedSince(2))?;
+        assert!(fetch_res.contains("* 1 FETCH (RFC822.SIZE 84 MODSEQ (3))"));
+        assert!(!fetch_res.contains("* 2 FETCH"));
+        assert_eq!(store_res.lines().count(), 2);
 
+        // RFC 3.1.5.  MODSEQ Search Criterion in SEARCH
+        let search_res = search(imap_socket, SearchKind::ModSeq(3))?;
+        // RFC 3.1.6.  Modified SEARCH Untagged Response
+        assert!(search_res.contains("* SEARCH 1 (MODSEQ 3)"));
 
-        //store(
+        // RFC 3.1.7   HIGHESTMODSEQ Status Data Items
+        let status_res = status(imap_socket, Mailbox::Inbox, StatusKind::HighestModSeq)?;
+        assert!(status_res.contains("HIGHESTMODSEQ 3"));
 
         Ok(())
     })

tests/common/fragments.rs

@@ -85,6 +85,26 @@ pub enum StoreMod {
     UnchangedSince(u64),
 }
 
+pub enum FetchKind {
+    Rfc822,
+    Rfc822Size,
+}
+
+pub enum FetchMod {
+    None,
+    ChangedSince(u64),
+}
+
+pub enum SearchKind<'a> {
+    Text(&'a str),
+    ModSeq(u64),
+}
+
+pub enum StatusKind {
+    UidNext,
+    HighestModSeq,
+}
+
 pub fn capability(imap: &mut TcpStream, ext: Extension) -> Result<()> {
     imap.write(&b"5 capability\r\n"[..])?;
 
@@ -145,7 +165,7 @@ pub fn create_mailbox(imap: &mut TcpStream, mbx: Mailbox) -> Result<()> {
     Ok(())
 }
 
-pub fn select(imap: &mut TcpStream, mbx: Mailbox, modifier: SelectMod, maybe_exists: Option<u64>) -> Result<()> {
+pub fn select(imap: &mut TcpStream, mbx: Mailbox, modifier: SelectMod) -> Result<String> {
     let mut buffer: [u8; 6000] = [0; 6000];
 
     let mbx_str = match mbx {
@@ -163,18 +183,8 @@ pub fn select(imap: &mut TcpStream, mbx: Mailbox, modifier: SelectMod, maybe_exi
 
     let read = read_lines(imap, &mut buffer, Some(&b"20 OK"[..]))?;
     let srv_msg = std::str::from_utf8(read)?;
-    if let Some(exists) = maybe_exists {
-        let expected = format!("* {} EXISTS", exists);
-        assert!(srv_msg.contains(&expected));
-    }
-    match modifier {
-        SelectMod::Condstore => {
-            assert!(srv_msg.contains("[HIGHESTMODSEQ"));
-        }
-        _ => (),
-    }
 
-    Ok(())
+    Ok(srv_msg.to_string())
 }
 
 pub fn unselect(imap: &mut TcpStream) -> Result<()> {
@@ -194,13 +204,22 @@ pub fn check(imap: &mut TcpStream) -> Result<()> {
     Ok(())
 }
 
-pub fn status_mailbox(imap: &mut TcpStream, mbx: Mailbox) -> Result<()> {
+pub fn status(imap: &mut TcpStream, mbx: Mailbox, sk: StatusKind) -> Result<String> {
-    assert!(matches!(mbx, Mailbox::Archive));
+    let mbx_str = match mbx {
-    imap.write(&b"25 STATUS Archive (UIDNEXT MESSAGES)\r\n"[..])?;
+        Mailbox::Inbox => "INBOX",
+        Mailbox::Archive => "Archive",
+        Mailbox::Drafts => "Drafts",
+    };
+    let sk_str = match sk {
+        StatusKind::UidNext => "(UIDNEXT)",
+        StatusKind::HighestModSeq => "(HIGHESTMODSEQ)",
+    };
+    imap.write(format!("25 STATUS {} {}\r\n", mbx_str, sk_str).as_bytes())?;
     let mut buffer: [u8; 6000] = [0; 6000];
-    let _read = read_lines(imap, &mut buffer, Some(&b"25 OK"[..]))?;
+    let read = read_lines(imap, &mut buffer, Some(&b"25 OK"[..]))?;
+    let srv_msg = std::str::from_utf8(read)?;
 
-    Ok(())
+    Ok(srv_msg.to_string())
 }
 
 pub fn lmtp_handshake(lmtp: &mut TcpStream) -> Result<()> {
@@ -267,23 +286,31 @@ pub fn noop_exists(imap: &mut TcpStream, must_exists: u32) -> Result<()> {
     }
 }
 
-pub fn fetch_rfc822(imap: &mut TcpStream, selection: Selection, r#ref: Email) -> Result<()> {
+pub fn fetch(imap: &mut TcpStream, selection: Selection, kind: FetchKind, modifier: FetchMod) -> Result<String> {
     let mut buffer: [u8; 65535] = [0; 65535];
 
-    assert!(matches!(selection, Selection::FirstId));
+    let sel_str = match selection {
-    imap.write(&b"40 fetch 1 rfc822\r\n"[..])?;
+        Selection::FirstId => "1",
+        Selection::SecondId => "2",
+        Selection::All => "1:*",
+    };
+
+    let kind_str = match kind {
+        FetchKind::Rfc822 => "RFC822",
+        FetchKind::Rfc822Size => "RFC822.SIZE",
+    };
+
+    let mod_str = match modifier {
+        FetchMod::None => "".into(),
+        FetchMod::ChangedSince(val) => format!(" (CHANGEDSINCE {})", val),
+    };
+
+    imap.write(format!("40 fetch {} {}{}\r\n", sel_str, kind_str, mod_str).as_bytes())?;
 
     let read = read_lines(imap, &mut buffer, Some(&b"40 OK FETCH"[..]))?;
     let srv_msg = std::str::from_utf8(read)?;
 
-    let ref_mail = match r#ref {
+    Ok(srv_msg.to_string())
-        Email::Basic => EMAIL2,
-        Email::Multipart => EMAIL1,
-    };
-    let orig_email = std::str::from_utf8(ref_mail)?;
-    assert!(srv_msg.contains(orig_email));
-
-    Ok(())
 }
 
 pub fn copy(imap: &mut TcpStream, selection: Selection, to: Mailbox) -> Result<()> {
@@ -323,11 +350,16 @@ pub fn append_email(imap: &mut TcpStream, content: Email) -> Result<()> {
     Ok(())
 }
 
-pub fn search(imap: &mut TcpStream) -> Result<()> {
+pub fn search(imap: &mut TcpStream, sk: SearchKind) -> Result<String> {
-    imap.write(&b"55 search text \"OoOoO\"\r\n"[..])?;
+    let sk_str = match sk {
+        SearchKind::Text(x) => format!("TEXT \"{}\"", x),
+        SearchKind::ModSeq(x) => format!("MODSEQ {}", x),
+    };
+    imap.write(format!("55 SEARCH {}\r\n", sk_str).as_bytes())?;
     let mut buffer: [u8; 1500] = [0; 1500];
-    let _read = read_lines(imap, &mut buffer, Some(&b"55 OK"[..]))?;
+    let read = read_lines(imap, &mut buffer, Some(&b"55 OK"[..]))?;
-    Ok(())
+    let srv_msg = std::str::from_utf8(read)?;
+    Ok(srv_msg.to_string())
 }
 
 pub fn store(