A little bit of information on SMTP
Role of fake SMTP server DebugMail: when and how can it help?
— Improve email testing: simplify and optimize with DebugMail
What’s this manual about?
Before starting the testing of the email functionality of the application
Installing Rust on your computer
— Downloading Rust and Cargo
— Checking installed versions of Rust and Cargo
Creating a project in DebugMail
Writing application code to connect to the fake SMTP server DebagMail
— Creating an application project
— Adding project dependencies
— Writing code to test the outgoing mail functionality of a Rust application
— Building an Rust application
— Running the application and testing email functionality
Afterword
Summary
Additional Resources
When sending emails from your application to customer’s email addresses, you have the option to utilize various outgoing mail servers such as Google, Mailjet, Unisender, or other similar services. Additionally, you can also configure and use your own SMTP server, for example, by employing Postfix.
Regardless of the above options, the underlying protocol you will be using to send emails remains SMTP. This means that it doesn’t matter which programming language you choose to develop your application in; you will still be able to send emails to your customers by simply leveraging the SMTP protocol. You have two approaches to achieve this:
Even after configuring an outgoing mail server and preparing to send emails, it is crucial to thoroughly test the email sending logic, especially if it involves specific criteria. It is important to ensure that your clients receive accurate emails containing correct data. Making mistakes in this aspect can lead to dissatisfaction among clients, as they understandably expect accurate and error-free communication from us.
In this scenario, you have two options to test your outgoing emails:
DebugMail specifically functions as a Fake SMTP server, meaning it doesn’t deliver emails to actual recipients. Instead, it captures and stores these emails within your DebugMail project, allowing you to analyze and identify any errors or inaccuracies. This eliminates the hassle of creating multiple real email accounts to simulate real customers and makes your work much easier.
Similar to a genuine outgoing mail server, DebugMail works with the SMTP protocol. This enables you to incorporate it into your projects regardless of the programming language used. Connecting to DebugMail or a real mail service follows the same method.
We recommend using DebugMail in the staging of your application development, so that you can easily and quickly test outgoing emails if there have been any changes in its logic. Just imagine how convenient it would be — you make changes to the logic of sending emails, the logic of composing email content, or the logic of selecting recipients. You need to make sure that everything is working correctly. By deploying updates to the staging environment where DebugMail is connected, you can quickly test all the scenarios related to outgoing emails — no need to register new mailboxes or add/change user addresses in your application. You can simply test your outgoing emails without any hassle.
As it was said above — it doesn’t matter what language you use to write your application. If you need to work with outgoing mail, you will use the SMTP protocol, which can be handled from any language. This can be implemented using a library, or it can be direct communication via SMTP with your server.
Specifically this manual will show a simple example of how you can use DebugMail in your Rust projects. We will create an account in DebugMail service and write a simple code in Rust that will allow us to send emails from the application. And all these sent emails will be stored in your DebugMail space. From where you can easily and simply analyze these emails and find errors or inaccuracies.
In this tutorial we will be using the Rust language and its package manager Cargo.
Since in this manual we will be working with Rust and its package manager Cargo, first you need to install everything we need, as well as create an account and a project in the DebugMail service.
We will be demonstrating an example using Ubuntu OS. The OS doesn’t matter much though. You can do all the same things but with some caveats on any other OS.
Open the terminal and go to the convenient folder where you will work and write our code.
Let’s upload Rust and Cargo on command:
curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
The file will be downloaded and the Rust installation will start. During the process, you will be asked which installation option you want → choose option 1 (default installation).
After the installation is complete, you should see the message in the console:
Rust is installed now. Great!
Let’s check the Rust version:
rustc --version
If Rust has been installed correctly, then you should see something like this:
rustc 1.72.1 (d5c2e9c34 2023-09-13)
Let’s check the Cargo version:
cargo --version
With Cargo installed correctly, you should see something like:
cargo 1.72.1 (103a7ff2e 2023-08-15)
Our main goal is to install the Rust compiler and Cargo package manager on your system.
If Rust or Cargo did not install correctly — find an error made during the Rust and Cargo installation process, or search Google for instructions on how to install Rust and Cargo on your system. It shouldn’t be difficult.
After installing Rust, you need to create an account on DebugMail. When you create an account, a team and a project, you will get access credentials that you will use to send emails through the DebugMail mail server.
Let’s create the project. Find the «New projects» button in the lower left corner of the screen and click on it. You will see the form of creation of the project. Enter the project name, save it.
Now you should see your created project:
As you can see, your project doesn’t have any emails yet. It’s time to fix it!
You need to obtain the necessary data that will be required in your Rust code to use DebugMail as your outgoing mail server.
In the «Project settings» menu at the bottom you will see host, port, login, and pass. You use this data in your Rust application.
Open the terminal in the folder where you will be developing your Rust application and run the command:
cargo new dm2_test_mail
This command will create a «skeleton» for your future Rust application. In our example, we decided to name the application dm2_test_mail. Although you can name it as you like.
Now open the created folder with the project in your favorite IDE.
In the folder with your project (our — dm2_test_mail) you will see a folder called «src» — it will contain your source files Rust.
Now this folder has main.rs. In this file we will write our code.
Since your Rust application will use the Lettre library to work with SMTP, you need to specify this library in the project dependencies.
Open the Cargo.toml file and change the dependencies section to:
[dependencies]
lettre = "0.10"
lettre_email = "0.9"
Save the changes.
Open the main.rs file in the src folder and paste the following code into it:
use lettre::{
message::header::ContentType, transport::smtp::authentication::Credentials, Message,
SmtpTransport, Transport,
};
fn main() {
let email = Message::builder()
.from("no-reply@example.com".parse().unwrap())
.reply_to("suport@example.com".parse().unwrap())
.to("customer@company.com".parse().unwrap())
.subject("Send email for Rust app")
.header(ContentType::TEXT_PLAIN)
.body(String::from("It really works?"))
.unwrap();
let creds = Credentials::new("8f3f072e-dfb4-482c-85c5-b7e90883ad3d".to_owned(), "5b8834bf-780f-4a7a-b172-f787c3782440".to_owned());
let mailer = SmtpTransport::builder_dangerous("app.debugmail.io")
.port(25)
.credentials(creds)
.build();
// Send the email
match mailer.send(&email) {
Ok(_) => println!("Email sent successfully!"),
Err(e) => panic!("Could not send email: {e:?}"),
}
}
Let’s explore what’s happening in our code.
use lettre::{
message::header::ContentType, transport::smtp::authentication::Credentials, Message,
SmtpTransport, Transport,
};
We specify which objects we will be using from the Lettre library.
fn main() {
Here we declare the main function, where the message sending will occur.
let email = Message::builder()
.from("no-reply@example.com".parse().unwrap())
.reply_to("suport@example.com".parse().unwrap())
.to("customer@company.com".parse().unwrap())
.subject("Send email for Rust app")
.header(ContentType::TEXT_PLAIN)
.body(String::from("It really works?"))
.unwrap();
We create a Message object and specify the following parameters:
from
— the sender of our email.reply_to
— the email address where the recipient should send a reply if they want to respond to this email.to
— the recipient’s email address.subject
— the subject of the email.header
— we add a ContentType header specifying the type as text/plain.body
— the body of the email. let creds = Credentials::new("8f3f072e-dfb4-482c-85c5-b7e90883ad3d".to_owned(), "5b8834bf-780f-4a7a-b172-f787c3782440".to_owned());
In here we create a Credentials object and provide our credentials for the DebugMail project. We need to specify the login and password for the outgoing mail server that we want to use.
Go to your DebugMail project, open the project settings, at the lowest bottom you will see the necessary data. You need to replace the login and password used in the code above with the login and password from your DebugMail project.
If you were using a different outgoing mail server, you would need to provide your login and password from that server.
let mailer = SmtpTransport::builder_dangerous("app.debugmail.io")
.port(25)
.credentials(creds)
.build();
In this section of code, we create a SmtpTransport object by passing it the host and port parameters of our mail server.
Also passed here is the creds object created earlier, which contains the login and password data for authenticating the user to DebugMail.
// Send the email
match mailer.send(&email) {
Ok(_) => println!("Email sent successfully!"),
Err(e) => panic!("Could not send email: {e:?}"),
}
This section of the code will attempt to send an email with the data generated earlier.
This is where the work of our program ends. All we have left to do is create our Rust app and run it.
Open the terminal and navigate to the folder with your Rust application. In our case, we call it as dm2_test_mail.
Execute command:
cargo build
We will acquire the necessary dependencies and proceed to compile your Rust application.
In the project folder (for us it is dm2_test_mail), you will see a new directory called «target». Your compiled application will be located in this folder. Specifically, in our case, the compiled application will reside in the directory — dm2_test_mail/target/debug/dm2_test_mail.
Open the terminal and navigate to the Rust project folder.
Execute command:
cargo run
This command will execute our program.
If you did everything correctly earlier, you will get the output “Email sent successfully!”. And our DebugMail project will receive the email sent by the program.
Let’s open our project in DebugMail and confirm that the email has been received as expected.
We’ve successfully achieved our goal! The email has arrived in our DebugMail project, thanks to the implementation of a simple Rust code that facilitates outgoing email sending. And we used DebugMail as our outgoing mail server.
It works!
In this manual, we have provided a basic example of how you can use DebugMail in your Rust applications using the Lettre library. We were able to write a simple Rust code and send an email to a user. However, we used the DebugMail service as our outgoing mail server, which helps us easily and quickly test outgoing email from our application, written in any language.
If you have understood the concept of this guide, you will be able to integrate any SMTP outgoing mail server into your application, including DebugMail.
Let’s summarize.
We recommend following this principle:
By following this principle, you can easily modify the logic of your outgoing email, test these changes using DebugMail, and only deliver your changes to production when you are confident that the outgoing email in your application is working correctly.
If you have any questions or need help with integration, just email us. We are always ready to help!
Author
Subscribe to DebugMail blog and receive notifications only about new articles