def test_unsupported_carrier(self):
# Arrange
mailbox = Mailbox('+15555555555', carrier='Foo Wireless')
# Act
result = mailbox.is_carrier_supported()
# Assert
self.assertFalse(result)
def test_supported_carrier(self):
# Arrange
mailbox = Mailbox('+15555555555', carrier='Verizon Wireless')
# Act
result = mailbox.is_carrier_supported()
# Assert
self.assertTrue(result)
def test_get_disable_code(self):
# Arrange
mailbox = Mailbox('+15555555555', carrier='Verizon Wireless')
# Act
disable_code = mailbox.get_disable_code()
# Assert
self.assertEqual(disable_code, '*73')
def test_get_call_forwarding_code(self):
# Arrange
mailbox = Mailbox('+15555555555', carrier='Verizon Wireless')
# Act
forwarding_code = mailbox.get_call_forwarding_code()
# Assert
self.assertEqual(forwarding_code, '*719999999999')
def test_get_region_code(self):
# Arrange
mailbox = Mailbox('+15555555555', carrier='Verizon Wireless')
# Act
region_code = mailbox.get_region_code()
# Assert
self.assertEqual(region_code, 'US')
def test_send_contact_info(self):
# Arrange
mailbox = Mailbox('+15555555555', name='Jane Foo', email='*****@*****.**', carrier='Foo Wireless')
mock_client = MagicMock()
# Act
with patch('app.models.get_twilio_rest_client', return_value=mock_client):
mailbox.send_contact_info('+17777777777')
# Assert
assert mock_client.messages.create.called
self.assertFalse(mailbox.call_forwarding_set)
def test_generate_config_image(self):
# Arrange
mailbox = Mailbox('+15555555555', carrier='Foo Wireless')
# Act
with patch('app.models.qrcode') as mock_qrcode:
mailbox.generate_config_image()
# Assert
assert mock_qrcode.make.called
qrcode_json = mock_qrcode.make.call_args[0][0]
self.assertIn('+1555555555', qrcode_json)
self.assertIn('"call_forwarding_set": false', qrcode_json)
self.assertNotIn('_sa_instance_state', qrcode_json)
def test_send_config_image(self):
# Arrange
mailbox = Mailbox('+15555555555', carrier='Foo Wireless')
mock_thread = MagicMock()
# Act
with patch('app.models.Thread', return_value=mock_thread) as MockThread:
mailbox.send_config_image()
# Assert
body = MockThread.call_args[1]['args'][1]
self.assertIn('Now get on with your life!', body)
media_url = MockThread.call_args[1]['args'][3]
self.assertEqual(media_url, 'http://localhost/config-image')
assert mock_thread.start.called
def test_qr_codes_yes(self):
# Arrange
mailbox = Mailbox(
phone_number='+15555555555',
carrier='Verizon Wireless',
name='Jane Foo',
email='*****@*****.**',
call_forwarding_set=True)
mailbox.send_config_image = MagicMock()
# Act
reply = _process_answer('YEAH', mailbox)
# Assert
self.assertEqual(mailbox.feelings_on_qr_codes, 'love')
self.assertIn('ME TOO', reply)
mailbox.send_config_image.assert_called_once_with()
def test_qr_codes_no(self):
# Arrange
mailbox = Mailbox(
phone_number='+15555555555',
carrier='Verizon Wireless',
name='Jane Foo',
email='*****@*****.**',
call_forwarding_set=True)
mailbox.send_config_image = MagicMock()
# Act
reply = _process_answer('not so much', mailbox)
# Assert
self.assertEqual(mailbox.feelings_on_qr_codes, 'hate')
self.assertIn('for nerds', reply)
self.assertFalse(mailbox.send_config_image.called)
def test_qr_codes_unsure(self):
# Arrange
mailbox = Mailbox(
phone_number='+15555555555',
carrier='Verizon Wireless',
name='Jane Foo',
email='*****@*****.**',
call_forwarding_set=True)
mailbox.send_config_image = MagicMock()
# Act
reply = _process_answer("I can take them or leave them", mailbox)
# Assert
self.assertIsNone(mailbox.feelings_on_qr_codes)
self.assertIn('kidder', reply)
self.assertFalse(mailbox.send_config_image.called)
def mailbox_already_used(email: str, user) -> bool:
if Mailbox.get_by(email=email, user_id=user.id):
return True
# support the case user wants to re-add their real email as mailbox
# can happen when user changes their root email and wants to add this new email as mailbox
if email == user.email:
return False
return False
def alias_transfer_receive_route():
"""
URL has ?alias_id=signed_alias_id
"""
token = request.args.get("token")
alias = Alias.get_by(transfer_token=token)
if not alias:
flash("Invalid link", "error")
return redirect(url_for("dashboard.index"))
# alias already belongs to this user
if alias.user_id == current_user.id:
flash("You already own this alias", "warning")
return redirect(url_for("dashboard.index"))
# check if user has not exceeded the alias quota
if not current_user.can_create_new_alias():
LOG.d("%s can't receive new alias", current_user)
flash(
"You have reached free plan limit, please upgrade to create new aliases",
"warning",
)
return redirect(url_for("dashboard.index"))
mailboxes = current_user.mailboxes()
if request.method == "POST":
mailbox_ids = request.form.getlist("mailbox_ids")
# check if mailbox is not tempered with
mailboxes = []
for mailbox_id in mailbox_ids:
mailbox = Mailbox.get(mailbox_id)
if (not mailbox or mailbox.user_id != current_user.id
or not mailbox.verified):
flash("Something went wrong, please retry", "warning")
return redirect(request.url)
mailboxes.append(mailbox)
if not mailboxes:
flash("You must select at least 1 mailbox", "warning")
return redirect(request.url)
LOG.d("transfer alias from %s to %s with %s", alias.user, current_user,
mailboxes)
transfer(alias, current_user, mailboxes)
flash(f"You are now owner of {alias.email}", "success")
return redirect(url_for("dashboard.index",
highlight_alias_id=alias.id))
return render_template(
"dashboard/alias_transfer_receive.html",
alias=alias,
mailboxes=mailboxes,
)
def handle_unsubscribe(envelope: Envelope):
msg = email.message_from_bytes(envelope.original_content)
# format: alias_id:
subject = msg["Subject"]
try:
# subject has the format {alias.id}=
if subject.endswith("="):
alias_id = int(subject[:-1])
# some email providers might strip off the = suffix
else:
alias_id = int(subject)
alias = Alias.get(alias_id)
except Exception:
LOG.warning("Cannot parse alias from subject %s", msg["Subject"])
return "550 SL E8"
if not alias:
LOG.warning("No such alias %s", alias_id)
return "550 SL E9"
# This sender cannot unsubscribe
mail_from = envelope.mail_from.lower().strip()
mailbox = Mailbox.get_by(user_id=alias.user_id, email=mail_from)
if not mailbox or mailbox not in alias.mailboxes:
LOG.d("%s cannot disable alias %s", envelope.mail_from, alias)
return "550 SL E10"
# Sender is owner of this alias
alias.enabled = False
db.session.commit()
user = alias.user
enable_alias_url = URL + f"/dashboard/?highlight_alias_id={alias.id}"
for mailbox in alias.mailboxes:
send_email(
mailbox.email,
f"Alias {alias.email} has been disabled successfully",
render(
"transactional/unsubscribe-disable-alias.txt",
user=user,
alias=alias.email,
enable_alias_url=enable_alias_url,
),
render(
"transactional/unsubscribe-disable-alias.html",
user=user,
alias=alias.email,
enable_alias_url=enable_alias_url,
),
)
return "250 Unsubscribe request accepted"
def test_update_custom_domains(flask_client):
user = login(flask_client)
d1 = CustomDomain.create(
user_id=user.id, domain="test1.org", verified=True, commit=True
)
# test update catch all
assert d1.catch_all is False
r = flask_client.patch(f"/api/custom_domains/{d1.id}", json={"catch_all": True})
assert r.status_code == 200
assert d1.catch_all is True
# make sure the full domain json is returned
cd_json = r.json["custom_domain"]
assert cd_json["domain_name"]
assert cd_json["id"] == d1.id
assert cd_json["nb_alias"] == 0
assert "is_verified" in cd_json
assert "catch_all" in cd_json
assert "name" in cd_json
assert "random_prefix_generation" in cd_json
assert cd_json["creation_date"]
assert cd_json["creation_timestamp"]
assert cd_json["mailboxes"]
for mailbox in cd_json["mailboxes"]:
assert "id" in mailbox
assert "email" in mailbox
# test update random_prefix_generation
assert d1.random_prefix_generation is False
r = flask_client.patch(
f"/api/custom_domains/{d1.id}", json={"random_prefix_generation": True}
)
assert r.status_code == 200
assert d1.random_prefix_generation is True
# test update name
assert d1.name is None
r = flask_client.patch(f"/api/custom_domains/{d1.id}", json={"name": "test name"})
assert r.status_code == 200
assert d1.name == "test name"
# test update mailboxes
assert d1.mailboxes == [user.default_mailbox]
mb = Mailbox.create(
user_id=user.id, email="*****@*****.**", verified=True, commit=True
)
r = flask_client.patch(
f"/api/custom_domains/{d1.id}", json={"mailbox_ids": [mb.id]}
)
assert r.status_code == 200
assert d1.mailboxes == [mb]
def test_send_info_to_user_restore(self):
# Arrange
mailbox = Mailbox('+15555555555', carrier='Foo Wireless', feelings_on_qr_codes='love')
mock_client = MagicMock()
mock_thread = MagicMock()
# Act
with patch('app.models.get_twilio_rest_client', return_value=mock_client):
with patch('app.models.Thread', return_value=mock_thread) as MockThread:
mailbox.send_contact_info('+15555555555')
# Assert
assert mock_client.messages.create.called
self.assertTrue(mailbox.call_forwarding_set)
body = MockThread.call_args[1]['args'][1]
self.assertIn('Now get on with your life!', body)
assert mock_thread.start.called
def test_delete_mailbox(flask_client):
user = login(flask_client)
# create a mailbox
mb = Mailbox.create(user_id=user.id, email="*****@*****.**")
db.session.commit()
r = flask_client.delete(
f"/api/mailboxes/{mb.id}",
)
assert r.status_code == 200
def email_already_used(email: str) -> bool:
"""test if an email can be used when:
- user signs up
- add a new mailbox
"""
if User.get_by(email=email):
return True
if Mailbox.get_by(email=email):
return True
return False
def test_success_v3(flask_client):
user = User.create(
email="[email protected]",
password="******",
name="Test User",
activated=True,
)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# create another mailbox
mb = Mailbox.create(user_id=user.id, email="*****@*****.**", verified=True)
db.session.commit()
# create new alias with note
word = random_word()
suffix = f".{word}@{EMAIL_DOMAIN}"
suffix = signer.sign(suffix).decode()
r = flask_client.post(
url_for("api.new_custom_alias_v3", hostname="www.test.com"),
headers={"Authentication": api_key.code},
json={
"alias_prefix": "prefix",
"signed_suffix": suffix,
"note": "test note",
"mailbox_ids": [user.default_mailbox_id, mb.id],
"name": "your name",
},
)
assert r.status_code == 201
assert r.json["alias"] == f"prefix.{word}@{EMAIL_DOMAIN}"
# assert returned field
res = r.json
assert "id" in res
assert "email" in res
assert "creation_date" in res
assert "creation_timestamp" in res
assert "nb_forward" in res
assert "nb_block" in res
assert "nb_reply" in res
assert "enabled" in res
assert "note" in res
assert res["name"] == "your name"
new_alias: Alias = Alias.get_by(email=r.json["alias"])
assert new_alias.note == "test note"
assert len(new_alias.mailboxes) == 2
def test_import_config_image_failure(self):
# Arrange
mock_response = MagicMock()
mock_response.json.side_effect = ValueError
# Act
with patch('app.models.requests.get', return_value=mock_response):
result = Mailbox.import_config_image('http://example.com')
# Assert
self.assertIn('Ooops!', result)
def test_get_mailboxes_v2(flask_client):
user = login(flask_client)
Mailbox.create(user_id=user.id, email="*****@*****.**", verified=True)
Mailbox.create(user_id=user.id, email="*****@*****.**", verified=False)
db.session.commit()
r = flask_client.get(
"/api/v2/mailboxes",
)
assert r.status_code == 200
# 3 mailboxes: the default, m1 and m2
assert len(r.json["mailboxes"]) == 3
for mb in r.json["mailboxes"]:
assert "email" in mb
assert "id" in mb
assert "default" in mb
assert "creation_timestamp" in mb
assert "nb_alias" in mb
assert "verified" in mb
def sanity_check():
"""
#TODO: investigate why DNS sometimes not working
Different sanity checks
- detect if there's mailbox that's using a invalid domain
"""
for mailbox in Mailbox.filter_by(verified=True).all():
# hack to not query DNS too often
sleep(1)
if not email_domain_can_be_used_as_mailbox(mailbox.email):
mailbox.nb_failed_checks += 1
nb_email_log = nb_email_log_for_mailbox(mailbox)
# alert if too much fail and nb_email_log > 100
if mailbox.nb_failed_checks > 10 and nb_email_log > 100:
log_func = LOG.exception
else:
log_func = LOG.warning
log_func(
"issue with mailbox %s domain. #alias %s, nb email log %s",
mailbox,
mailbox.nb_alias(),
nb_email_log,
)
else: # reset nb check
mailbox.nb_failed_checks = 0
db.session.commit()
for user in User.filter_by(activated=True).all():
if user.email.lower() != user.email:
LOG.exception("%s does not have lowercase email", user)
for mailbox in Mailbox.filter_by(verified=True).all():
if mailbox.email.lower() != mailbox.email:
LOG.exception("%s does not have lowercase email", mailbox)
LOG.d("Finish sanity check")
def delete_mailbox(mailbox_id):
"""
Delete mailbox
Input:
mailbox_id: in url
Output:
200 if deleted successfully
"""
user = g.user
mailbox = Mailbox.get(mailbox_id)
if not mailbox or mailbox.user_id != user.id:
return jsonify(error="Forbidden"), 403
if mailbox.id == user.default_mailbox_id:
return jsonify(error="You cannot delete the default mailbox"), 400
Mailbox.delete(mailbox_id)
db.session.commit()
return jsonify(deleted=True), 200
def test_add_domain_used_in_mailbox(flask_client):
"""cannot add domain if it has been used in a verified mailbox"""
user = login(flask_client)
user.lifetime = True
Session.commit()
Mailbox.create(user_id=user.id,
email="*****@*****.**",
verified=True,
commit=True)
r = flask_client.post(
url_for("dashboard.custom_domain"),
data={
"form-name": "create",
"domain": "new-domain.com"
},
follow_redirects=True,
)
assert r.status_code == 200
assert b"new-domain.com already used in a SimpleLogin mailbox" in r.data
def alias_transfer_receive_route():
"""
URL has ?alias_id=signed_alias_id
"""
s = Signer(ALIAS_TRANSFER_SECRET)
signed_alias_id = request.args.get("alias_id")
try:
alias_id = int(s.unsign(signed_alias_id))
except Exception:
flash("Invalid link", "error")
return redirect(url_for("dashboard.index"))
else:
alias = Alias.get(alias_id)
# alias already belongs to this user
if alias.user_id == current_user.id:
flash("You already own this alias", "warning")
return redirect(url_for("dashboard.index"))
mailboxes = current_user.mailboxes()
if request.method == "POST":
mailbox_ids = request.form.getlist("mailbox_ids")
# check if mailbox is not tempered with
mailboxes = []
for mailbox_id in mailbox_ids:
mailbox = Mailbox.get(mailbox_id)
if (not mailbox or mailbox.user_id != current_user.id
or not mailbox.verified):
flash("Something went wrong, please retry", "warning")
return redirect(request.url)
mailboxes.append(mailbox)
if not mailboxes:
flash("You must select at least 1 mailbox", "warning")
return redirect(request.url)
LOG.d("transfer alias from %s to %s with %s", alias.user, current_user,
mailboxes)
transfer(alias, current_user, mailboxes)
flash(f"You are now owner of {alias.email}", "success")
return redirect(url_for("dashboard.index",
highlight_alias_id=alias.id))
return render_template(
"dashboard/alias_transfer_receive.html",
alias=alias,
mailboxes=mailboxes,
)
def test_update_mailbox_email(flask_client):
user = User.create(
email="[email protected]", password="******", name="Test User", activated=True
)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# create a mailbox
mb = Mailbox.create(user_id=user.id, email="*****@*****.**")
db.session.commit()
r = flask_client.put(
f"/api/mailboxes/{mb.id}",
headers={"Authentication": api_key.code},
json={"email": "*****@*****.**"},
)
assert r.status_code == 200
mb = Mailbox.get(mb.id)
assert mb.new_email == "*****@*****.**"
def delete_mailbox(mailbox_id: int):
from server import create_light_app
with create_light_app().app_context():
mailbox = Mailbox.get(mailbox_id)
if not mailbox:
return
mailbox_email = mailbox.email
user = mailbox.user
Mailbox.delete(mailbox_id)
db.session.commit()
LOG.d("Mailbox %s %s deleted", mailbox_id, mailbox_email)
send_email(
user.email,
f"Your mailbox {mailbox_email} has been deleted",
f"""Mailbox {mailbox_email} along with its aliases are deleted successfully.
Regards,
SimpleLogin team.
""",
)
def mailbox_confirm_change_route():
s = Signer(MAILBOX_SECRET)
signed_mailbox_id = request.args.get("mailbox_id")
try:
mailbox_id = int(s.unsign(signed_mailbox_id))
except Exception:
flash("Invalid link", "error")
return redirect(url_for("dashboard.index"))
else:
mailbox = Mailbox.get(mailbox_id)
# new_email can be None if user cancels change in the meantime
if mailbox and mailbox.new_email:
user = mailbox.user
if Mailbox.get_by(email=mailbox.new_email, user_id=user.id):
flash(f"{mailbox.new_email} is already used", "error")
return redirect(
url_for("dashboard.mailbox_detail_route",
mailbox_id=mailbox.id))
mailbox.email = mailbox.new_email
mailbox.new_email = None
# mark mailbox as verified if the change request is sent from an unverified mailbox
mailbox.verified = True
Session.commit()
LOG.d("Mailbox change %s is verified", mailbox)
flash(f"The {mailbox.email} is updated", "success")
return redirect(
url_for("dashboard.mailbox_detail_route",
mailbox_id=mailbox.id))
else:
flash("Invalid link", "error")
return redirect(url_for("dashboard.index"))
def test_get_mailboxes(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
Mailbox.create(user_id=user.id, email="*****@*****.**", verified=True)
Mailbox.create(user_id=user.id, email="*****@*****.**", verified=False)
db.session.commit()
r = flask_client.get(
url_for("api.get_mailboxes"),
headers={"Authentication": api_key.code},
)
assert r.status_code == 200
# [email protected] is not returned as it's not verified
assert r.json == {
"mailboxes": [
{
"email": "[email protected]",
"id": 1,
"default": True
},
{
"email": "*****@*****.**",
"id": 2,
"default": False
},
]
}
print(json.dumps(r.json, indent=2))
def test_update_alias_mailboxes(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
mb1 = Mailbox.create(user_id=user.id, email="*****@*****.**", verified=True)
mb2 = Mailbox.create(user_id=user.id, email="*****@*****.**", verified=True)
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
alias = Alias.create_new_random(user)
db.session.commit()
r = flask_client.put(
url_for("api.update_alias", alias_id=alias.id),
headers={"Authentication": api_key.code},
json={"mailbox_ids": [mb1.id, mb2.id]},
)
assert r.status_code == 200
alias = Alias.get(alias.id)
assert alias.mailbox
assert len(alias._mailboxes) == 1
# fail when update with empty mailboxes
r = flask_client.put(
url_for("api.update_alias", alias_id=alias.id),
headers={"Authentication": api_key.code},
json={"mailbox_ids": []},
)
assert r.status_code == 400
def test_mailbox_delete(flask_client):
user = User.create(
email="[email protected]",
password="******",
name="Test User",
activated=True,
commit=True,
)
m1 = Mailbox.create(user_id=user.id,
email="*****@*****.**",
verified=True,
commit=True)
m2 = Mailbox.create(user_id=user.id,
email="*****@*****.**",
verified=True,
commit=True)
m3 = Mailbox.create(user_id=user.id,
email="*****@*****.**",
verified=True,
commit=True)
# alias has 2 mailboxes
alias = Alias.create_new(user, "prefix", mailbox_id=m1.id)
Session.commit()
alias._mailboxes.append(m2)
alias._mailboxes.append(m3)
Session.commit()
assert len(alias.mailboxes) == 3
# delete m1, should not delete alias
Mailbox.delete(m1.id)
alias = Alias.get(alias.id)
assert len(alias.mailboxes) == 2
def test_cancel_mailbox_email_change(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# create a mailbox
mb = Mailbox.create(user_id=user.id, email="*****@*****.**")
db.session.commit()
# update mailbox email
r = flask_client.put(
url_for("api.delete_mailbox", mailbox_id=mb.id),
headers={"Authentication": api_key.code},
json={"email": "*****@*****.**"},
)
assert r.status_code == 200
mb = Mailbox.get(mb.id)
assert mb.new_email == "*****@*****.**"
# cancel mailbox email change
r = flask_client.put(
url_for("api.delete_mailbox", mailbox_id=mb.id),
headers={"Authentication": api_key.code},
json={"cancel_email_change": True},
)
assert r.status_code == 200
mb = Mailbox.get(mb.id)
assert mb.new_email is None
def sanity_check():
"""
#TODO: investigate why DNS sometimes not working
Different sanity checks
- detect if there's mailbox that's using a invalid domain
"""
for mailbox in Mailbox.filter_by(verified=True).all():
# hack to not query DNS too often
sleep(1)
if not email_domain_can_be_used_as_mailbox(mailbox.email):
mailbox.nb_failed_checks += 1
nb_email_log = nb_email_log_for_mailbox(mailbox)
# alert if too much fail and nb_email_log > 100
if mailbox.nb_failed_checks > 10 and nb_email_log > 100:
log_func = LOG.exception
mailbox.verified = False
else:
log_func = LOG.warning
log_func(
"issue with mailbox %s domain. #alias %s, nb email log %s",
mailbox,
mailbox.nb_alias(),
nb_email_log,
)
else: # reset nb check
mailbox.nb_failed_checks = 0
db.session.commit()
for user in User.filter_by(activated=True).all():
if user.email.lower().strip().replace(" ", "") != user.email:
LOG.exception("%s does not have sanitized email", user)
for alias in Alias.query.all():
if alias.email.lower().strip().replace(" ", "") != alias.email:
LOG.exception("Alias %s email not sanitized", alias)
for contact in Contact.query.all():
if contact.reply_email.lower().strip().replace(" ", "") != contact.reply_email:
LOG.exception("Contact %s reply-email not sanitized", contact)
for mailbox in Mailbox.query.all():
if mailbox.email.lower().strip().replace(" ", "") != mailbox.email:
LOG.exception("Mailbox %s address not sanitized", mailbox)
LOG.d("Finish sanity check")
def cancel_mailbox_change_route(mailbox_id):
mailbox = Mailbox.get(mailbox_id)
if not mailbox or mailbox.user_id != current_user.id:
flash("You cannot see this page", "warning")
return redirect(url_for("dashboard.index"))
if mailbox.new_email:
mailbox.new_email = None
db.session.commit()
flash("Your mailbox change is cancelled", "success")
return redirect(
url_for("dashboard.mailbox_detail_route", mailbox_id=mailbox_id))
else:
flash("You have no pending mailbox change", "warning")
return redirect(
url_for("dashboard.mailbox_detail_route", mailbox_id=mailbox_id))
def get_mailboxes_v2():
"""
Get all mailboxes - including unverified mailboxes
Output:
- mailboxes: list of mailbox dict
"""
user = g.user
mailboxes = []
for mailbox in Mailbox.filter_by(user_id=user.id):
mailboxes.append(mailbox)
return (
jsonify(mailboxes=[mailbox_to_dict(mb) for mb in mailboxes]),
200,
)
def test_full_payload(flask_client):
"""Create alias with:
- additional mailbox
- note
- name
- hostname (in URL)
"""
user = login(flask_client)
# create another mailbox
mb = Mailbox.create(user_id=user.id, email="*****@*****.**", verified=True)
Session.commit()
word = random_word()
suffix = f".{word}@{EMAIL_DOMAIN}"
signed_suffix = signer.sign(suffix).decode()
assert AliasUsedOn.count() == 0
r = flask_client.post(
"/api/v3/alias/custom/new?hostname=example.com",
json={
"alias_prefix": "prefix",
"signed_suffix": signed_suffix,
"note": "test note",
"mailbox_ids": [user.default_mailbox_id, mb.id],
"name": "your name",
},
)
assert r.status_code == 201
assert r.json["alias"] == f"prefix.{word}@{EMAIL_DOMAIN}"
# assert returned field
res = r.json
assert res["note"] == "test note"
assert res["name"] == "your name"
new_alias: Alias = Alias.get_by(email=r.json["alias"])
assert new_alias.note == "test note"
assert len(new_alias.mailboxes) == 2
alias_used_on = AliasUsedOn.first()
assert alias_used_on.alias_id == new_alias.id
assert alias_used_on.hostname == "example.com"
def mailbox_verify():
s = Signer(MAILBOX_SECRET)
mailbox_id = request.args.get("mailbox_id")
try:
r_id = int(s.unsign(mailbox_id))
except Exception:
flash("Invalid link. Please delete and re-add your mailbox", "error")
return redirect(url_for("dashboard.mailbox_route"))
else:
mailbox = Mailbox.get(r_id)
mailbox.verified = True
db.session.commit()
LOG.d("Mailbox %s is verified", mailbox)
return render_template("dashboard/mailbox_validation.html",
mailbox=mailbox)
def test_get_alias_infos_with_pagination_v3_no_duplicate(flask_client):
"""When an alias belongs to multiple mailboxes, make sure get_alias_infos_with_pagination_v3
returns no duplicates
"""
user = User.create(
email="[email protected]",
password="******",
name="Test User",
activated=True,
commit=True,
)
alias = Alias.first()
mb = Mailbox.create(user_id=user.id, email="*****@*****.**")
alias._mailboxes.append(mb)
Session.commit()
alias_infos = get_alias_infos_with_pagination_v3(user)
assert len(alias_infos) == 1
def test_get_alias_infos_with_pagination_v3_query_alias_mailboxes(flask_client):
"""test the query on the alias additional mailboxes"""
user = User.create(
email="[email protected]",
password="******",
name="Test User",
activated=True,
commit=True,
)
alias = Alias.first()
mb = Mailbox.create(user_id=user.id, email="*****@*****.**")
alias._mailboxes.append(mb)
Session.commit()
alias_infos = get_alias_infos_with_pagination_v3(user, mailbox_id=mb.id)
assert len(alias_infos) == 1
alias_infos = get_alias_infos_with_pagination_v3(user, query=alias.email)
assert len(alias_infos) == 1
def test_delete_mailbox(flask_client):
user = User.create(
email="[email protected]", password="******", name="Test User", activated=True
)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# create a mailbox
mb = Mailbox.create(user_id=user.id, email="*****@*****.**")
db.session.commit()
r = flask_client.delete(
f"/api/mailboxes/{mb.id}",
headers={"Authentication": api_key.code},
)
assert r.status_code == 200
def create_mailbox():
"""
Create a new mailbox. User needs to verify the mailbox via an activation email.
Input:
email: in body
Output:
the new mailbox
- id
- email
- verified
"""
user = g.user
mailbox_email = request.get_json().get("email").lower().strip().replace(
" ", "")
if mailbox_already_used(mailbox_email, user):
return jsonify(error=f"{mailbox_email} already used"), 400
elif not email_domain_can_be_used_as_mailbox(mailbox_email):
return (
jsonify(
error=
f"{mailbox_email} cannot be used. Please note a mailbox cannot "
f"be a disposable email address"),
400,
)
else:
new_mailbox = Mailbox.create(email=mailbox_email, user_id=user.id)
db.session.commit()
send_verification_email(user, new_mailbox)
return (
jsonify(
id=new_mailbox.id,
email=new_mailbox.email,
verified=new_mailbox.verified,
default=user.default_mailbox_id == new_mailbox.id,
),
201,
)
def test_import_config_image(self):
# Arrange
# Start off with an existing Mailbox
mailbox = Mailbox('+15555555555', carrier='Foo Wireless', call_forwarding_set=True)
db.session.add(mailbox)
db.session.commit()
mock_response = MagicMock()
mock_response.json.return_value = [{'type': 'qrcode', 'symbol': [{'data': '{"id": 1, "feelings_on_qr_codes": "love", "phone_number": "+15555555555", "name": "Jane Foo", "email": "*****@*****.**", "call_forwarding_set": false, "carrier": "Foo Wireless"}', 'error': None, 'seq': 0}]}]
# Act
with patch('app.models.requests.get', return_value=mock_response):
result = Mailbox.import_config_image('http://example.com')
# Assert
self.assertEqual(Mailbox.query.count(), 1)
imported_mailbox = Mailbox.query.one()
self.assertEqual(mailbox.phone_number, '+15555555555')
self.assertFalse(mailbox.call_forwarding_set)
self.assertIn('Now I remember *everything* about you', result)
def test_update_custom_domains(flask_client):
user = login(flask_client)
d1 = CustomDomain.create(
user_id=user.id, domain="test1.org", verified=True, commit=True
)
# test update catch all
assert d1.catch_all is False
r = flask_client.patch(f"/api/custom_domains/{d1.id}", json={"catch_all": True})
assert r.status_code == 200
assert d1.catch_all is True
# test update random_prefix_generation
assert d1.random_prefix_generation is False
r = flask_client.patch(
f"/api/custom_domains/{d1.id}", json={"random_prefix_generation": True}
)
assert r.status_code == 200
assert d1.random_prefix_generation is True
# test update name
assert d1.name is None
r = flask_client.patch(f"/api/custom_domains/{d1.id}", json={"name": "test name"})
assert r.status_code == 200
assert d1.name == "test name"
# test update mailboxes
assert d1.mailboxes == [user.default_mailbox]
mb = Mailbox.create(
user_id=user.id, email="*****@*****.**", verified=True, commit=True
)
r = flask_client.patch(
f"/api/custom_domains/{d1.id}", json={"mailbox_ids": [mb.id]}
)
assert r.status_code == 200
assert d1.mailboxes == [mb]
def create_mailbox():
"""
Create a new mailbox. User needs to verify the mailbox via an activation email.
Input:
email: in body
Output:
the new mailbox dict
"""
user = g.user
mailbox_email = sanitize_email(request.get_json().get("email"))
if not user.is_premium():
return jsonify(
error=f"Only premium plan can add additional mailbox"), 400
if not is_valid_email(mailbox_email):
return jsonify(error=f"{mailbox_email} invalid"), 400
elif mailbox_already_used(mailbox_email, user):
return jsonify(error=f"{mailbox_email} already used"), 400
elif not email_can_be_used_as_mailbox(mailbox_email):
return (
jsonify(
error=
f"{mailbox_email} cannot be used. Please note a mailbox cannot "
f"be a disposable email address"),
400,
)
else:
new_mailbox = Mailbox.create(email=mailbox_email, user_id=user.id)
Session.commit()
send_verification_email(user, new_mailbox)
return (
jsonify(mailbox_to_dict(new_mailbox)),
201,
)