Merge pull request #685 from deltachat/outlook_unit_test

Unit test Outlook autodiscovery

src/configure/auto_outlook.rs

@@ -3,6 +3,7 @@ use quick_xml::events::BytesEnd;
 
 use crate::constants::*;
 use crate::context::Context;
+use crate::error::Error;
 use crate::login_param::LoginParam;
 
 use super::read_autoconf_file;
@@ -19,14 +20,12 @@ struct OutlookAutodiscover {
     pub config_redirecturl: Option<String>,
 }
 
-pub fn outlk_autodiscover(
+enum ParsingResult {
-    context: &Context,
+    LoginParam(LoginParam),
-    url: &str,
+    RedirectUrl(String),
-    _param_in: &LoginParam,
+}
-) -> Option<LoginParam> {
+
-    let mut url = url.to_string();
+fn outlk_parse_xml(xml_raw: &str) -> Result<ParsingResult, Error> {
-    /* Follow up to 10 xml-redirects (http-redirects are followed in read_autoconf_file() */
-    for _i in 0..10 {
     let mut outlk_ad = OutlookAutodiscover {
         out: LoginParam::new(),
         out_imap_set: false,
@@ -38,7 +37,6 @@ pub fn outlk_autodiscover(
         config_redirecturl: None,
     };
 
-        if let Some(xml_raw) = read_autoconf_file(context, &url) {
     let mut reader = quick_xml::Reader::from_str(&xml_raw);
     reader.trim_text(true);
 
@@ -72,22 +70,19 @@ pub fn outlk_autodiscover(
 
                 if let Some(ref tag) = current_tag {
                     match tag.as_str() {
-                                "type" => outlk_ad.config_type = Some(val.trim().to_string()),
+                        "type" => {
+                            outlk_ad.config_type = Some(val.trim().to_lowercase().to_string())
+                        }
                         "server" => outlk_ad.config_server = val.trim().to_string(),
-                                "port" => {
+                        "port" => outlk_ad.config_port = val.trim().parse().unwrap_or_default(),
-                                    outlk_ad.config_port = val.trim().parse().unwrap_or_default()
-                                }
                         "ssl" => outlk_ad.config_ssl = val.trim().to_string(),
-                                "redirecturl" => {
+                        "redirecturl" => outlk_ad.config_redirecturl = Some(val.trim().to_string()),
-                                    outlk_ad.config_redirecturl = Some(val.trim().to_string())
-                                }
                         _ => {}
                     };
                 }
             }
             Err(e) => {
-                        error!(
+                bail!(
-                            context,
                     "Configure xml: Error at position {}: {:?}",
                     reader.buffer_position(),
                     e
@@ -109,12 +104,34 @@ pub fn outlk_autodiscover(
             || outlk_ad.out.send_port == 0
         {
             let r = outlk_ad.out.to_string();
-                    warn!(context, "Bad or incomplete autoconfig: {}", r,);
+            bail!("Bad or incomplete autoconfig: {}", r,);
+        }
+        Ok(ParsingResult::LoginParam(outlk_ad.out))
+    } else {
+        Ok(ParsingResult::RedirectUrl(
+            outlk_ad.config_redirecturl.unwrap(),
+        ))
+    }
+}
+
+pub fn outlk_autodiscover(
+    context: &Context,
+    url: &str,
+    _param_in: &LoginParam,
+) -> Option<LoginParam> {
+    let mut url = url.to_string();
+    /* Follow up to 10 xml-redirects (http-redirects are followed in read_autoconf_file() */
+    for _i in 0..10 {
+        if let Some(xml_raw) = read_autoconf_file(context, &url) {
+            match outlk_parse_xml(&xml_raw) {
+                Err(err) => {
+                    warn!(context, "{}", err);
                     return None;
                 }
-                return Some(outlk_ad.out);
+                Ok(res) => match res {
-            } else {
+                    ParsingResult::RedirectUrl(redirect_url) => url = redirect_url,
-                url = outlk_ad.config_redirecturl.unwrap();
+                    ParsingResult::LoginParam(login_param) => return Some(login_param),
+                },
             }
         } else {
             return None;
@@ -155,3 +172,78 @@ fn outlk_autodiscover_endtag_cb(event: &BytesEnd, outlk_ad: &mut OutlookAutodisc
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_redirect() {
+        let res = outlk_parse_xml("
+<?xml version=\"1.0\" encoding=\"utf-8\"?>
+  <Autodiscover xmlns=\"http://schemas.microsoft.com/exchange/autodiscover/responseschema/2006\">
+    <Response xmlns=\"http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a\">
+      <Account>
+        <AccountType>email</AccountType>
+        <Action>redirectUrl</Action>
+        <RedirectUrl>https://mail.example.com/autodiscover/autodiscover.xml</RedirectUrl>
+      </Account>
+    </Response>
+  </Autodiscover>
+ ").expect("XML is not parsed successfully");
+        match res {
+            ParsingResult::LoginParam(_lp) => {
+                panic!("redirecturl is not found");
+            }
+            ParsingResult::RedirectUrl(url) => {
+                assert_eq!(
+                    url,
+                    "https://mail.example.com/autodiscover/autodiscover.xml"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_parse_loginparam() {
+        let res = outlk_parse_xml(
+            "\
+<?xml version=\"1.0\" encoding=\"utf-8\"?>
+<Autodiscover xmlns=\"http://schemas.microsoft.com/exchange/autodiscover/responseschema/2006\">
+  <Response xmlns=\"http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a\">
+    <Account>
+      <AccountType>email</AccountType>
+      <Action>settings</Action>
+      <Protocol>
+        <Type>IMAP</Type>
+        <Server>example.com</Server>
+        <Port>993</Port>
+        <SSL>on</SSL>
+        <AuthRequired>on</AuthRequired>
+      </Protocol>
+      <Protocol>
+        <Type>SMTP</Type>
+        <Server>smtp.example.com</Server>
+        <Port>25</Port>
+        <SSL>off</SSL>
+        <AuthRequired>on</AuthRequired>
+      </Protocol>
+    </Account>
+  </Response>
+</Autodiscover>",
+        )
+        .expect("XML is not parsed successfully");
+
+        match res {
+            ParsingResult::LoginParam(lp) => {
+                assert_eq!(lp.mail_server, "example.com");
+                assert_eq!(lp.mail_port, 993);
+                assert_eq!(lp.send_server, "smtp.example.com");
+                assert_eq!(lp.send_port, 25);
+            }
+            ParsingResult::RedirectUrl(_) => {
+                panic!("RedirectUrl is not expected");
+            }
+        }
+    }
+}