Product
Introducing License Enforcement in Socket
Ensure open-source compliance with Socket’s License Enforcement Beta. Set up your License Policy and secure your software!
The Mailosaur Python library lets you integrate email and SMS testing into your continuous integration process.
Mailosaur lets you automate email and SMS tests as part of software development and QA.
This guide provides several key sections:
You can find the full Mailosaur documentation on the website.
If you get stuck, just contact us at support@mailosaur.com.
pip install --upgrade mailosaur
Then import the library into your code. The value for YOUR_API_KEY
is covered in the next step (creating an account):
from mailosaur import MailosaurClient
mailosaur = MailosaurClient("YOUR_API_KEY")
This library is powered by the Mailosaur email & SMS testing API. You can easily check out the API itself by looking at our API reference documentation or via our Postman or Insomnia collections:
Create a free trial account for Mailosaur via the website.
Once you have this, navigate to the API tab to find the following values:
Mailosaur gives you an unlimited number of test email addresses - with no setup or coding required!
Here's how it works:
abc123.mailosaur.net
)@{YOUR_SERVER_DOMAIN}
will work with Mailosaur without any special setup. For example:
build-423@abc123.mailosaur.net
john.smith@abc123.mailosaur.net
rAnDoM63423@abc123.mailosaur.net
Can't use test email addresses? You can also use SMTP to test email. By connecting your product or website to Mailosaur via SMTP, Mailosaur will catch all email your application sends, regardless of the email address.
In automated tests you will want to wait for a new email to arrive. This library makes that easy with the messages.get
method. Here's how you use it:
from mailosaur import MailosaurClient
from mailosaur.models import SearchCriteria
mailosaur = MailosaurClient("API_KEY")
# See https://mailosaur.com/app/project/api
server_id = "abc123"
server_domain = "abc123.mailosaur.net"
criteria = SearchCriteria()
criteria.sent_to = "anything@" + server_domain
email = mailosaur.messages.get(server_id, criteria)
print(email.subject) # "Hello world!"
MailosaurClient
with your API key.abc123
.Important: Trial accounts do not automatically have SMS access. Please contact our support team to enable a trial of SMS functionality.
If your account has SMS testing enabled, you can reserve phone numbers to test with, then use the Mailosaur API in a very similar way to when testing email:
from mailosaur import MailosaurClient
from mailosaur.models import SearchCriteria
mailosaur = MailosaurClient("API_KEY")
# See https://mailosaur.com/app/project/api
server_id = "abc123"
server_domain = "abc123.mailosaur.net"
criteria = SearchCriteria()
criteria.sent_to = "4471235554444"
sms = mailosaur.messages.get(server_id, criteria)
print(sms.text.body)
Most emails, and all SMS messages, should have a plain text body. Mailosaur exposes this content via the text.body
property on an email or SMS message:
print(message.text.body) # "Hi Jason, ..."
if "Jason" in message.text.body:
print('Email contains "Jason"')
You may have an email or SMS message that contains an account verification code, or some other one-time passcode. You can extract content like this using a simple regex.
Here is how to extract a 6-digit numeric code:
print(message.text.body) # "Your access code is 243546."
match = re.search("([0-9]{6})", message.text.body)
print(match.group()) # "243546"
Most emails also have an HTML body, as well as the plain text content. You can access HTML content in a very similar way to plain text:
print(message.html.body) # "<html><head ..."
If you need to traverse the HTML content of an email. For example, finding an element via a CSS selector, you can use the Beautiful Soup library.
pip install beautifulsoup4
from bs4 import BeautifulSoup
# ...
dom = BeautifulSoup(message.html.body, 'html.parser')
el = dom.find('.verification-code')
verification_code = el.text
print(verification_code) # "542163"
When an email is sent with an HTML body, Mailosaur automatically extracts any hyperlinks found within anchor (<a>
) and area (<area>
) elements and makes these viable via the html.links
array.
Each link has a text property, representing the display text of the hyperlink within the body, and an href property containing the target URL:
# How many links?
print(len(message.html.links)) # 2
first_link = message.html.links[0]
print(first_link.text) # "Google Search"
print(first_link.href) # "https://www.google.com/"
Important: To ensure you always have valid emails. Mailosaur only extracts links that have been correctly marked up with <a>
or <area>
tags.
Mailosaur auto-detects links in plain text content too, which is especially useful for SMS testing:
# How many links?
print(len(message.text.links)) # 2
first_link = message.text.links[0]
print(first_link.href) # "https://www.google.com/"
If your email includes attachments, you can access these via the attachments
property:
# How many attachments?
print(len(message.attachments)) # 2
Each attachment contains metadata on the file name and content type:
first_attachment = message.attachments[0]
print(first_attachment.file_name) # "contract.pdf"
print(first_attachment.content_type) # "application/pdf"
The length
property returns the size of the attached file (in bytes):
first_attachment = message.attachments[0]
print(first_attachment.length) # 4028
The html.images
property of a message contains an array of images found within the HTML content of an email. The length of this array corresponds to the number of images found within an email:
# How many images in the email?
print(len(message.html.images)) # 1
Emails will often contain many images that are hosted elsewhere, such as on your website or product. It is recommended to check that these images are accessible by your recipients.
All images should have an alternative text description, which can be checked using the alt
attribute.
image = message.html.images[0]
print(image.alt) # "Hot air balloon"
A web beacon is a small image that can be used to track whether an email has been opened by a recipient.
Because a web beacon is simply another form of remotely-hosted image, you can use the src
attribute to perform an HTTP request to that address:
import requests
# ...
const image = message.html.images[0]
print(image.src) # "https://example.com/s.png?abc123"
# Make an HTTP call to trigger the web beacon
response = requests.get(image.src)
print(response.status_code) # 200
You can perform a SpamAssassin check against an email. The structure returned matches the spam test object:
result = mailosaur.analysis.spam(message.id)
print(result.score) # 0.5
for r in result.spam_filter_results.spam_assassin:
print(r.rule)
print(r.description)
print(r.score)
You must have the following prerequisites installed:
Install all development dependencies:
pip install -r requirements.txt
The test suite requires the following environment variables to be set:
export MAILOSAUR_BASE_URL=https://mailosaur.com/
export MAILOSAUR_API_KEY=your_api_key
export MAILOSAUR_SERVER=server_id
Run all tests:
pytest
You can get us at support@mailosaur.com
FAQs
The Mailosaur Python library lets you integrate email and SMS testing into your continuous integration process.
We found that mailosaur demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Product
Ensure open-source compliance with Socket’s License Enforcement Beta. Set up your License Policy and secure your software!
Product
We're launching a new set of license analysis and compliance features for analyzing, managing, and complying with licenses across a range of supported languages and ecosystems.
Product
We're excited to introduce Socket Optimize, a powerful CLI command to secure open source dependencies with tested, optimized package overrides.