Prepare 0.10.0-beta.2

* Implement CustomizeConnection::on_release() for SmtpConnection

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "lettre"
 # remember to update html_root_url and README.md (Cargo.toml example and deps.rs badge)
-version = "0.10.0-beta.1"
+version = "0.10.0-beta.2"
 description = "Email client"
 readme = "README.md"
 homepage = "https://lettre.rs"

README.md

@@ -28,8 +28,8 @@
 </div>
 
 <div align="center">
-  <a href="https://deps.rs/crate/lettre/0.10.0-beta.1">
+  <a href="https://deps.rs/crate/lettre/0.10.0-beta.2">
-    <img src="https://deps.rs/crate/lettre/0.10.0-beta.1/status.svg"
+    <img src="https://deps.rs/crate/lettre/0.10.0-beta.2/status.svg"
       alt="dependency status" />
   </a>
 </div>
@@ -66,7 +66,7 @@ To use this library, add the following to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-lettre = "0.10.0-beta.1"
+lettre = "0.10.0-beta.2"
 ```
 
 ```rust,no_run

examples/asyncstd1_smtp_starttls.rs

@@ -1,6 +1,6 @@
 use lettre::{
     transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
-    AsyncStd1Transport, Message,
+    AsyncTransport, Message,
 };
 
 #[async_std::main]

examples/asyncstd1_smtp_tls.rs

@@ -1,6 +1,6 @@
 use lettre::{
     transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
-    AsyncStd1Transport, Message,
+    AsyncTransport, Message,
 };
 
 #[async_std::main]

examples/tokio02_smtp_starttls.rs

@@ -4,8 +4,8 @@
 use tokio02_crate as tokio;
 
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio02Executor,
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio02Transport,
+    Tokio02Executor,
 };
 
 #[tokio::main]

examples/tokio02_smtp_tls.rs

@@ -4,8 +4,8 @@
 use tokio02_crate as tokio;
 
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio02Executor,
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio02Transport,
+    Tokio02Executor,
 };
 
 #[tokio::main]

examples/tokio1_smtp_starttls.rs

@@ -4,8 +4,8 @@
 use tokio1_crate as tokio;
 
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio1Executor,
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio1Transport,
+    Tokio1Executor,
 };
 
 #[tokio::main]

examples/tokio1_smtp_tls.rs

@@ -4,8 +4,8 @@
 use tokio1_crate as tokio;
 
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio1Executor,
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio1Transport,
+    Tokio1Executor,
 };
 
 #[tokio::main]

src/lib.rs

@@ -30,7 +30,7 @@
 //! * **serde**: Serialization/Deserialization of entities
 //! * **hostname**: Ability to try to use actual hostname in SMTP transaction
 
-#![doc(html_root_url = "https://docs.rs/crate/lettre/0.10.0-beta.1")]
+#![doc(html_root_url = "https://docs.rs/crate/lettre/0.10.0-beta.2")]
 #![doc(html_favicon_url = "https://lettre.rs/favicon.ico")]
 #![doc(html_logo_url = "https://avatars0.githubusercontent.com/u/15113230?v=4")]
 #![forbid(unsafe_code)]
@@ -92,29 +92,8 @@ pub use crate::transport::smtp::AsyncSmtpTransport;
 pub use crate::transport::Transport;
 use crate::{address::Envelope, error::Error};
 
-#[doc(hidden)]
-#[allow(deprecated)]
-#[cfg(all(feature = "smtp-transport", feature = "async-std1"))]
-pub use crate::transport::smtp::AsyncStd1Connector;
 #[cfg(feature = "smtp-transport")]
 pub use crate::transport::smtp::SmtpTransport;
-#[doc(hidden)]
-#[allow(deprecated)]
-#[cfg(all(feature = "smtp-transport", feature = "tokio02"))]
-pub use crate::transport::smtp::Tokio02Connector;
-#[doc(hidden)]
-#[allow(deprecated)]
-#[cfg(all(feature = "smtp-transport", feature = "tokio1"))]
-pub use crate::transport::smtp::Tokio1Connector;
-#[doc(hidden)]
-#[cfg(feature = "async-std1")]
-pub use crate::transport::AsyncStd1Transport;
-#[doc(hidden)]
-#[cfg(feature = "tokio02")]
-pub use crate::transport::Tokio02Transport;
-#[doc(hidden)]
-#[cfg(feature = "tokio1")]
-pub use crate::transport::Tokio1Transport;
 
 #[cfg(test)]
 #[cfg(feature = "builder")]

src/transport/smtp/async_transport.rs

@@ -271,22 +271,3 @@ where
         }
     }
 }
-
-#[doc(hidden)]
-#[deprecated(note = "use lettre::Executor instead")]
-pub use crate::Executor as AsyncSmtpConnector;
-
-#[doc(hidden)]
-#[deprecated(note = "use lettre::Tokio02Executor instead")]
-#[cfg(feature = "tokio02")]
-pub type Tokio02Connector = crate::Tokio02Executor;
-
-#[doc(hidden)]
-#[deprecated(note = "use lettre::Tokio1Executor instead")]
-#[cfg(feature = "tokio1")]
-pub type Tokio1Connector = crate::Tokio1Executor;
-
-#[doc(hidden)]
-#[deprecated(note = "use lettre::AsyncStd1Executor instead")]
-#[cfg(feature = "async-std1")]
-pub type AsyncStd1Connector = crate::AsyncStd1Executor;

src/transport/smtp/mod.rs

@@ -117,9 +117,7 @@
 //! ```
 
 #[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
-pub use self::async_transport::{
+pub use self::async_transport::{AsyncSmtpTransport, AsyncSmtpTransportBuilder};
-    AsyncSmtpConnector, AsyncSmtpTransport, AsyncSmtpTransportBuilder,
-};
 #[cfg(feature = "r2d2")]
 pub use self::pool::PoolConfig;
 #[cfg(feature = "r2d2")]
@@ -139,19 +137,6 @@ use crate::transport::smtp::{
 use client::Tls;
 use std::time::Duration;
 
-#[doc(hidden)]
-#[allow(deprecated)]
-#[cfg(feature = "async-std1")]
-pub use self::async_transport::AsyncStd1Connector;
-#[doc(hidden)]
-#[allow(deprecated)]
-#[cfg(feature = "tokio02")]
-pub use self::async_transport::Tokio02Connector;
-#[doc(hidden)]
-#[allow(deprecated)]
-#[cfg(feature = "tokio1")]
-pub use self::async_transport::Tokio1Connector;
-
 #[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
 mod async_transport;
 pub mod authentication;

src/transport/smtp/pool.rs

@@ -2,7 +2,7 @@ use std::time::Duration;
 
 use crate::transport::smtp::{client::SmtpConnection, error::Error, SmtpClient};
 
-use r2d2::{ManageConnection, Pool};
+use r2d2::{CustomizeConnection, ManageConnection, Pool};
 
 /// Configuration for a connection pool
 #[derive(Debug, Clone)]
@@ -53,12 +53,16 @@ impl PoolConfig {
         self
     }
 
-    pub(crate) fn build<C: ManageConnection>(&self, client: C) -> Pool<C> {
+    pub(crate) fn build<C: ManageConnection<Connection = SmtpConnection, Error = Error>>(
+        &self,
+        client: C,
+    ) -> Pool<C> {
         Pool::builder()
             .min_idle(Some(self.min_idle))
             .max_size(self.max_size)
             .connection_timeout(self.connection_timeout)
             .idle_timeout(Some(self.idle_timeout))
+            .connection_customizer(Box::new(SmtpConnectionQuitter))
             .build_unchecked(client)
     }
 }
@@ -93,3 +97,15 @@ impl ManageConnection for SmtpClient {
         conn.has_broken()
     }
 }
+
+#[derive(Copy, Clone, Debug)]
+struct SmtpConnectionQuitter;
+
+impl CustomizeConnection<SmtpConnection, Error> for SmtpConnectionQuitter {
+    fn on_release(&self, conn: SmtpConnection) {
+        let mut conn = conn;
+        if !conn.has_broken() {
+            let _quit = conn.quit();
+        }
+    }
+}

tests/transport_file.rs

@@ -1,18 +1,14 @@
 #[cfg(test)]
 #[cfg(all(feature = "file-transport", feature = "builder"))]
-mod test {
+mod sync {
-    use lettre::{transport::file::FileTransport, Message};
+    use lettre::{FileTransport, Message, Transport};
     use std::{
         env::temp_dir,
         fs::{read_to_string, remove_file},
     };
 
-    #[cfg(feature = "tokio02")]
-    use tokio02_crate as tokio;
-
     #[test]
     fn file_transport() {
-        use lettre::Transport;
         let sender = FileTransport::new(temp_dir());
         let email = Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
@@ -48,7 +44,6 @@ mod test {
     #[test]
     #[cfg(feature = "file-transport-envelope")]
     fn file_transport_with_envelope() {
-        use lettre::Transport;
         let sender = FileTransport::with_envelope(temp_dir());
         let email = Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
@@ -95,49 +90,21 @@ mod test {
         remove_file(eml_file).unwrap();
         remove_file(json_file).unwrap();
     }
+}
 
-    #[cfg(feature = "async-std1")]
+#[cfg(test)]
-    #[async_std::test]
+#[cfg(all(feature = "file-transport", feature = "builder", feature = "tokio02"))]
-    async fn file_transport_asyncstd1() {
+mod tokio_02 {
-        use lettre::{AsyncFileTransport, AsyncStd1Executor, AsyncTransport};
+    use lettre::{AsyncFileTransport, AsyncTransport, Message, Tokio02Executor};
+    use std::{
+        env::temp_dir,
+        fs::{read_to_string, remove_file},
+    };
 
-        let sender = AsyncFileTransport::<AsyncStd1Executor>::new(temp_dir());
+    use tokio02_crate as tokio;
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
-            .unwrap();
 
-        let result = sender.send(email).await;
-        let id = result.unwrap();
-
-        let eml_file = temp_dir().join(format!("{}.eml", id));
-        let eml = read_to_string(&eml_file).unwrap();
-
-        assert_eq!(
-            eml,
-            concat!(
-                "From: NoBody <nobody@domain.tld>\r\n",
-                "Reply-To: Yuin <yuin@domain.tld>\r\n",
-                "To: Hei <hei@domain.tld>\r\n",
-                "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "Be happy!"
-            )
-        );
-        remove_file(eml_file).unwrap();
-    }
-
-    #[cfg(feature = "tokio02")]
     #[tokio::test]
     async fn file_transport_tokio02() {
-        use lettre::{AsyncFileTransport, AsyncTransport, Tokio02Executor};
-
         let sender = AsyncFileTransport::<Tokio02Executor>::new(temp_dir());
         let email = Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
@@ -170,3 +137,98 @@ mod test {
         remove_file(eml_file).unwrap();
     }
 }
+
+#[cfg(test)]
+#[cfg(all(feature = "file-transport", feature = "builder", feature = "tokio1"))]
+mod tokio_1 {
+    use lettre::{AsyncFileTransport, AsyncTransport, Message, Tokio1Executor};
+    use std::{
+        env::temp_dir,
+        fs::{read_to_string, remove_file},
+    };
+
+    use tokio1_crate as tokio;
+
+    #[cfg(feature = "tokio02")]
+    #[tokio::test]
+    async fn file_transport_tokio1() {
+        let sender = AsyncFileTransport::<Tokio1Executor>::new(temp_dir());
+        let email = Message::builder()
+            .from("NoBody <nobody@domain.tld>".parse().unwrap())
+            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
+            .to("Hei <hei@domain.tld>".parse().unwrap())
+            .subject("Happy new year")
+            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
+            .body(String::from("Be happy!"))
+            .unwrap();
+
+        let result = sender.send(email).await;
+        let id = result.unwrap();
+
+        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml = read_to_string(&eml_file).unwrap();
+
+        assert_eq!(
+            eml,
+            concat!(
+                "From: NoBody <nobody@domain.tld>\r\n",
+                "Reply-To: Yuin <yuin@domain.tld>\r\n",
+                "To: Hei <hei@domain.tld>\r\n",
+                "Subject: Happy new year\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
+                "Content-Transfer-Encoding: 7bit\r\n",
+                "\r\n",
+                "Be happy!"
+            )
+        );
+        remove_file(eml_file).unwrap();
+    }
+}
+
+#[cfg(test)]
+#[cfg(all(
+    feature = "file-transport",
+    feature = "builder",
+    feature = "async-std1"
+))]
+mod asyncstd_1 {
+    use lettre::{AsyncFileTransport, AsyncStd1Executor, AsyncTransport, Message};
+    use std::{
+        env::temp_dir,
+        fs::{read_to_string, remove_file},
+    };
+
+    #[async_std::test]
+    async fn file_transport_asyncstd1() {
+        let sender = AsyncFileTransport::<AsyncStd1Executor>::new(temp_dir());
+        let email = Message::builder()
+            .from("NoBody <nobody@domain.tld>".parse().unwrap())
+            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
+            .to("Hei <hei@domain.tld>".parse().unwrap())
+            .subject("Happy new year")
+            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
+            .body(String::from("Be happy!"))
+            .unwrap();
+
+        let result = sender.send(email).await;
+        let id = result.unwrap();
+
+        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml = read_to_string(&eml_file).unwrap();
+
+        assert_eq!(
+            eml,
+            concat!(
+                "From: NoBody <nobody@domain.tld>\r\n",
+                "Reply-To: Yuin <yuin@domain.tld>\r\n",
+                "To: Hei <hei@domain.tld>\r\n",
+                "Subject: Happy new year\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
+                "Content-Transfer-Encoding: 7bit\r\n",
+                "\r\n",
+                "Be happy!"
+            )
+        );
+        remove_file(eml_file).unwrap();
+    }
+}

tests/transport_sendmail.rs

@@ -1,14 +1,10 @@
 #[cfg(test)]
 #[cfg(all(feature = "sendmail-transport", feature = "builder"))]
-mod test {
+mod sync {
-    use lettre::{transport::sendmail::SendmailTransport, Message};
+    use lettre::{Message, SendmailTransport, Transport};
-
-    #[cfg(feature = "tokio02")]
-    use tokio02_crate as tokio;
 
     #[test]
     fn sendmail_transport() {
-        use lettre::Transport;
         let sender = SendmailTransport::new();
         let email = Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
@@ -22,32 +18,20 @@ mod test {
         println!("{:?}", result);
         assert!(result.is_ok());
     }
+}
 
-    #[cfg(feature = "async-std1")]
+#[cfg(test)]
-    #[async_std::test]
+#[cfg(all(
-    async fn sendmail_transport_asyncstd1() {
+    feature = "sendmail-transport",
-        use lettre::{AsyncSendmailTransport, AsyncStd1Executor, AsyncTransport};
+    feature = "builder",
+    feature = "tokio02"
+))]
+mod tokio_02 {
+    use lettre::{AsyncSendmailTransport, AsyncTransport, Message, Tokio02Executor};
+    use tokio02_crate as tokio;
 
-        let sender = AsyncSendmailTransport::<AsyncStd1Executor>::new();
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
-            .unwrap();
-
-        let result = sender.send(email).await;
-        println!("{:?}", result);
-        assert!(result.is_ok());
-    }
-
-    #[cfg(feature = "tokio02")]
     #[tokio::test]
     async fn sendmail_transport_tokio02() {
-        use lettre::{AsyncSendmailTransport, Tokio02Executor, Tokio02Transport};
-
         let sender = AsyncSendmailTransport::<Tokio02Executor>::new();
         let email = Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
@@ -63,3 +47,58 @@ mod test {
         assert!(result.is_ok());
     }
 }
+
+#[cfg(test)]
+#[cfg(all(
+    feature = "sendmail-transport",
+    feature = "builder",
+    feature = "tokio1"
+))]
+mod tokio_1 {
+    use lettre::{AsyncSendmailTransport, AsyncTransport, Message, Tokio1Executor};
+    use tokio1_crate as tokio;
+
+    #[tokio::test]
+    async fn sendmail_transport_tokio1() {
+        let sender = AsyncSendmailTransport::<Tokio1Executor>::new();
+        let email = Message::builder()
+            .from("NoBody <nobody@domain.tld>".parse().unwrap())
+            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
+            .to("Hei <hei@domain.tld>".parse().unwrap())
+            .subject("Happy new year")
+            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
+            .body(String::from("Be happy!"))
+            .unwrap();
+
+        let result = sender.send(email).await;
+        println!("{:?}", result);
+        assert!(result.is_ok());
+    }
+}
+
+#[cfg(test)]
+#[cfg(all(
+    feature = "sendmail-transport",
+    feature = "builder",
+    feature = "async-std1"
+))]
+mod asyncstd_1 {
+    use lettre::{AsyncSendmailTransport, AsyncStd1Executor, AsyncTransport, Message};
+
+    #[async_std::test]
+    async fn sendmail_transport_asyncstd1() {
+        let sender = AsyncSendmailTransport::<AsyncStd1Executor>::new();
+        let email = Message::builder()
+            .from("NoBody <nobody@domain.tld>".parse().unwrap())
+            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
+            .to("Hei <hei@domain.tld>".parse().unwrap())
+            .subject("Happy new year")
+            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
+            .body(String::from("Be happy!"))
+            .unwrap();
+
+        let result = sender.send(email).await;
+        println!("{:?}", result);
+        assert!(result.is_ok());
+    }
+}

tests/transport_smtp.rs

@@ -1,6 +1,6 @@
 #[cfg(test)]
 #[cfg(all(feature = "smtp-transport", feature = "builder"))]
-mod test {
+mod sync {
     use lettre::{Message, SmtpTransport, Transport};
 
     #[test]
@@ -12,10 +12,87 @@ mod test {
             .subject("Happy new year")
             .body(String::from("Be happy!"))
             .unwrap();
-        SmtpTransport::builder_dangerous("127.0.0.1")
+
+        let sender = SmtpTransport::builder_dangerous("127.0.0.1")
             .port(2525)
-            .build()
+            .build();
-            .send(&email)
+        sender.send(&email).unwrap();
-            .unwrap();
+    }
+}
+
+#[cfg(test)]
+#[cfg(all(feature = "smtp-transport", feature = "builder", feature = "tokio02"))]
+mod tokio_02 {
+    use lettre::{AsyncSmtpTransport, AsyncTransport, Message, Tokio02Executor};
+
+    use tokio02_crate as tokio;
+
+    #[tokio::test]
+    async fn smtp_transport_simple_tokio02() {
+        let email = Message::builder()
+            .from("NoBody <nobody@domain.tld>".parse().unwrap())
+            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
+            .to("Hei <hei@domain.tld>".parse().unwrap())
+            .subject("Happy new year")
+            .body(String::from("Be happy!"))
+            .unwrap();
+
+        let sender: AsyncSmtpTransport<Tokio02Executor> =
+            AsyncSmtpTransport::<Tokio02Executor>::builder_dangerous("127.0.0.1")
+                .port(2525)
+                .build();
+        sender.send(email).await.unwrap();
+    }
+}
+
+#[cfg(test)]
+#[cfg(all(feature = "smtp-transport", feature = "builder", feature = "tokio1"))]
+mod tokio_1 {
+    use lettre::{AsyncSmtpTransport, AsyncTransport, Message, Tokio1Executor};
+
+    use tokio1_crate as tokio;
+
+    #[tokio::test]
+    async fn smtp_transport_simple_tokio1() {
+        let email = Message::builder()
+            .from("NoBody <nobody@domain.tld>".parse().unwrap())
+            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
+            .to("Hei <hei@domain.tld>".parse().unwrap())
+            .subject("Happy new year")
+            .body(String::from("Be happy!"))
+            .unwrap();
+
+        let sender: AsyncSmtpTransport<Tokio1Executor> =
+            AsyncSmtpTransport::<Tokio1Executor>::builder_dangerous("127.0.0.1")
+                .port(2525)
+                .build();
+        sender.send(email).await.unwrap();
+    }
+}
+
+#[cfg(test)]
+#[cfg(all(
+    feature = "smtp-transport",
+    feature = "builder",
+    feature = "async-std1"
+))]
+mod asyncstd_1 {
+    use lettre::{AsyncSmtpTransport, AsyncStd1Executor, AsyncTransport, Message};
+
+    #[async_std::test]
+    async fn smtp_transport_simple_asyncstd1() {
+        let email = Message::builder()
+            .from("NoBody <nobody@domain.tld>".parse().unwrap())
+            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
+            .to("Hei <hei@domain.tld>".parse().unwrap())
+            .subject("Happy new year")
+            .body(String::from("Be happy!"))
+            .unwrap();
+
+        let sender: AsyncSmtpTransport<AsyncStd1Executor> =
+            AsyncSmtpTransport::<AsyncStd1Executor>::builder_dangerous("127.0.0.1")
+                .port(2525)
+                .build();
+        sender.send(email).await.unwrap();
     }
 }

tests/transport_smtp_pool.rs

@@ -1,7 +1,6 @@
 #[cfg(all(test, feature = "smtp-transport", feature = "r2d2"))]
-mod test {
+mod sync {
     use lettre::{address::Envelope, SmtpTransport, Transport};
-
     use std::{sync::mpsc, thread};
 
     fn envelope() -> Envelope {

tests/transport_stub.rs

@@ -1,14 +1,10 @@
 #[cfg(test)]
 #[cfg(feature = "builder")]
-mod test {
+mod sync {
-    use lettre::{transport::stub::StubTransport, Message};
+    use lettre::{transport::stub::StubTransport, Message, Transport};
-
-    #[cfg(feature = "tokio02")]
-    use tokio02_crate as tokio;
 
     #[test]
     fn stub_transport() {
-        use lettre::Transport;
         let sender_ok = StubTransport::new_ok();
         let sender_ko = StubTransport::new_error();
         let email = Message::builder()
@@ -22,32 +18,65 @@ mod test {
         sender_ok.send(&email).unwrap();
         sender_ko.send(&email).unwrap_err();
     }
+}
 
-    #[cfg(feature = "async-std1")]
+#[cfg(test)]
-    #[async_std::test]
+#[cfg(all(feature = "builder", feature = "tokio02"))]
-    async fn stub_transport_asyncstd1() {
+mod tokio_02 {
-        use lettre::AsyncStd1Transport;
+    use lettre::{transport::stub::StubTransport, AsyncTransport, Message};
 
-        let sender_ok = StubTransport::new_ok();
+    use tokio02_crate as tokio;
-        let sender_ko = StubTransport::new_error();
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
-            .unwrap();
 
-        sender_ok.send(email.clone()).await.unwrap();
-        sender_ko.send(email).await.unwrap_err();
-    }
-
-    #[cfg(feature = "tokio02")]
     #[tokio::test]
     async fn stub_transport_tokio02() {
-        use lettre::Tokio02Transport;
+        let sender_ok = StubTransport::new_ok();
-
+        let sender_ko = StubTransport::new_error();
+        let email = Message::builder()
+            .from("NoBody <nobody@domain.tld>".parse().unwrap())
+            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
+            .to("Hei <hei@domain.tld>".parse().unwrap())
+            .subject("Happy new year")
+            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
+            .body(String::from("Be happy!"))
+            .unwrap();
+
+        sender_ok.send(email.clone()).await.unwrap();
+        sender_ko.send(email).await.unwrap_err();
+    }
+}
+
+#[cfg(test)]
+#[cfg(all(feature = "builder", feature = "tokio1"))]
+mod tokio_1 {
+    use lettre::{transport::stub::StubTransport, AsyncTransport, Message};
+
+    use tokio1_crate as tokio;
+
+    #[tokio::test]
+    async fn stub_transport_tokio1() {
+        let sender_ok = StubTransport::new_ok();
+        let sender_ko = StubTransport::new_error();
+        let email = Message::builder()
+            .from("NoBody <nobody@domain.tld>".parse().unwrap())
+            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
+            .to("Hei <hei@domain.tld>".parse().unwrap())
+            .subject("Happy new year")
+            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
+            .body(String::from("Be happy!"))
+            .unwrap();
+
+        sender_ok.send(email.clone()).await.unwrap();
+        sender_ko.send(email).await.unwrap_err();
+    }
+}
+
+#[cfg(test)]
+#[cfg(all(feature = "builder", feature = "async-std1"))]
+mod asyncstd_1 {
+    use lettre::{transport::stub::StubTransport, AsyncTransport, Message};
+
+    #[async_std::test]
+    async fn stub_transport_asyncstd1() {
         let sender_ok = StubTransport::new_ok();
         let sender_ko = StubTransport::new_error();
         let email = Message::builder()