from random import random from flask import url_for, g from app import config from app.alias_suffix import ( get_alias_suffixes, AliasSuffix, signer, verify_prefix_suffix, ) from app.alias_utils import delete_alias from app.config import EMAIL_DOMAIN from app.db import Session from app.models import ( Mailbox, CustomDomain, Alias, DomainDeletedAlias, DeletedAlias, SLDomain, DailyMetric, ) from app.utils import random_word from tests.utils import login, random_domain, create_new_user def test_add_alias_success(flask_client): user = login(flask_client) suffix = f".{int(random() * 100000)}@{EMAIL_DOMAIN}" alias_suffix = AliasSuffix( is_custom=False, suffix=suffix, signed_suffix=signer.sign(suffix).decode(), is_premium=False, domain=EMAIL_DOMAIN, ) # create with a single mailbox r = flask_client.post( url_for("dashboard.custom_alias"), data={ "prefix": "prefix", "signed-alias-suffix": alias_suffix.signed_suffix, "mailboxes": [user.default_mailbox_id], }, follow_redirects=True, ) assert r.status_code == 200 assert f"Alias prefix{alias_suffix.suffix} has been created" in str(r.data) alias = Alias.order_by(Alias.created_at.desc()).first() assert not alias._mailboxes def test_add_alias_increment_nb_daily_metric_alias(flask_client): user = login(flask_client) daily_metric = DailyMetric.get_or_create_today_metric() Session.commit() nb_alias = daily_metric.nb_alias suffix = f".{int(random() * 100000)}@{EMAIL_DOMAIN}" alias_suffix = AliasSuffix( is_custom=False, suffix=suffix, signed_suffix=signer.sign(suffix).decode(), is_premium=False, domain=EMAIL_DOMAIN, ) # create with a single mailbox r = flask_client.post( url_for("dashboard.custom_alias"), data={ "prefix": "prefix", "signed-alias-suffix": alias_suffix.signed_suffix, "mailboxes": [user.default_mailbox_id], }, follow_redirects=True, ) assert r.status_code == 200 new_daily_metric = DailyMetric.get_or_create_today_metric() assert new_daily_metric.nb_alias == nb_alias + 1 def test_add_alias_multiple_mailboxes(flask_client): user = login(flask_client) Session.commit() suffix = f".{int(random() * 100000)}@{EMAIL_DOMAIN}" alias_suffix = AliasSuffix( is_custom=False, suffix=suffix, signed_suffix=signer.sign(suffix).decode(), is_premium=False, domain=EMAIL_DOMAIN, ) # create with a multiple mailboxes mb1 = Mailbox.create(user_id=user.id, email="m1@example.com", verified=True) Session.commit() r = flask_client.post( url_for("dashboard.custom_alias"), data={ "prefix": "prefix", "signed-alias-suffix": alias_suffix.signed_suffix, "mailboxes": [user.default_mailbox_id, mb1.id], }, follow_redirects=True, ) assert r.status_code == 200 assert f"Alias prefix{alias_suffix.suffix} has been created" in str(r.data) alias = Alias.order_by(Alias.created_at.desc()).first() assert alias._mailboxes def test_not_show_unverified_mailbox(flask_client): """make sure user unverified mailbox is not shown to user""" user = login(flask_client) Session.commit() Mailbox.create(user_id=user.id, email="m1@example.com", verified=True) Mailbox.create(user_id=user.id, email="m2@example.com", verified=False) Session.commit() r = flask_client.get(url_for("dashboard.custom_alias")) assert "m1@example.com" in str(r.data) assert "m2@example.com" not in str(r.data) def test_verify_prefix_suffix(flask_client): user = login(flask_client) Session.commit() CustomDomain.create(user_id=user.id, domain="test.com", ownership_verified=True) assert verify_prefix_suffix(user, "prefix", "@test.com") assert not verify_prefix_suffix(user, "prefix", "@abcd.com") word = random_word() suffix = f".{word}@{EMAIL_DOMAIN}" assert verify_prefix_suffix(user, "prefix", suffix) def test_available_suffixes(flask_client): user = login(flask_client) CustomDomain.create(user_id=user.id, domain="test.com", ownership_verified=True) assert len(get_alias_suffixes(user)) > 0 # first suffix is custom domain first_suffix = get_alias_suffixes(user)[0] assert first_suffix.is_custom assert first_suffix.suffix == "@test.com" assert first_suffix.signed_suffix.startswith("@test.com") def test_available_suffixes_default_domain(flask_client): user = login(flask_client) sl_domain = SLDomain.first() CustomDomain.create( user_id=user.id, domain="test.com", ownership_verified=True, commit=True ) user.default_alias_public_domain_id = sl_domain.id # first suffix is SL Domain first_suffix = get_alias_suffixes(user)[0] assert first_suffix.suffix.endswith(f"@{sl_domain.domain}") user.default_alias_public_domain_id = None # first suffix is custom domain first_suffix = get_alias_suffixes(user)[0] assert first_suffix.suffix == "@test.com" def test_available_suffixes_random_prefix_generation(flask_client): user = login(flask_client) CustomDomain.create( user_id=user.id, domain="test.com", ownership_verified=True, commit=True ) cd2 = CustomDomain.create( user_id=user.id, domain="test2.com", ownership_verified=True, commit=True ) user.default_alias_custom_domain_id = cd2.id # first suffix is test2.com first_suffix = get_alias_suffixes(user)[0] assert first_suffix.suffix == "@test2.com" cd2.random_prefix_generation = True # e.g. .meo@test2.com first_suffix = get_alias_suffixes(user)[0] assert first_suffix.suffix.endswith("@test2.com") assert first_suffix.suffix.startswith(".") def test_available_suffixes_hidden_domain(flask_client): user = login(flask_client) nb_suffix = len(get_alias_suffixes(user)) sl_domain = SLDomain.create(domain=random_domain(), commit=True) assert len(get_alias_suffixes(user)) == nb_suffix + 1 sl_domain.hidden = True Session.commit() assert len(get_alias_suffixes(user)) == nb_suffix def test_available_suffixes_domain_order(flask_client): user = login(flask_client) domain = random_domain() # will be the last domain as other domains have order=0 sl_domain = SLDomain.create(domain=domain, order=1, commit=True) last_suffix_info = get_alias_suffixes(user)[-1] assert last_suffix_info.suffix.endswith(domain) # now will be the first domain sl_domain.order = -1 Session.commit() first_suffix_info = get_alias_suffixes(user)[0] assert first_suffix_info.suffix.endswith(domain) def test_add_already_existed_alias(flask_client): user = login(flask_client) Session.commit() another_user = create_new_user() word = random_word() suffix = f".{word}@{EMAIL_DOMAIN}" alias_suffix = AliasSuffix( is_custom=False, suffix=suffix, signed_suffix=signer.sign(suffix).decode(), is_premium=False, domain=EMAIL_DOMAIN, ) # alias already exist Alias.create( user_id=another_user.id, email=f"prefix{suffix}", mailbox_id=another_user.default_mailbox_id, commit=True, ) # create the same alias, should return error r = flask_client.post( url_for("dashboard.custom_alias"), data={ "prefix": "prefix", "signed-alias-suffix": alias_suffix.signed_suffix, "mailboxes": [user.default_mailbox_id], }, follow_redirects=True, ) assert r.status_code == 200 assert f"prefix{suffix} cannot be used" in r.get_data(True) def test_add_alias_in_global_trash(flask_client): user = login(flask_client) Session.commit() another_user = create_new_user() word = random_word() suffix = f".{word}@{EMAIL_DOMAIN}" alias_suffix = AliasSuffix( is_custom=False, suffix=suffix, signed_suffix=signer.sign(suffix).decode(), is_premium=False, domain=EMAIL_DOMAIN, ) # delete an alias: alias should go the DeletedAlias alias = Alias.create( user_id=another_user.id, email=f"prefix{suffix}", mailbox_id=another_user.default_mailbox_id, commit=True, ) prev_deleted = DeletedAlias.count() delete_alias(alias, another_user) assert prev_deleted + 1 == DeletedAlias.count() # create the same alias, should return error r = flask_client.post( url_for("dashboard.custom_alias"), data={ "prefix": "prefix", "signed-alias-suffix": alias_suffix.signed_suffix, "mailboxes": [user.default_mailbox_id], }, follow_redirects=True, ) assert r.status_code == 200 assert f"prefix{suffix} cannot be used" in r.get_data(True) def test_add_alias_in_custom_domain_trash(flask_client): user = login(flask_client) for deleted_domain in DomainDeletedAlias.all(): Session.delete(deleted_domain) Session.flush() domain = random_domain() custom_domain = CustomDomain.create( user_id=user.id, domain=domain, ownership_verified=True, commit=True ) # delete a custom-domain alias: alias should go the DomainDeletedAlias alias = Alias.create( user_id=user.id, email=f"prefix@{domain}", custom_domain_id=custom_domain.id, mailbox_id=user.default_mailbox_id, commit=True, ) assert DomainDeletedAlias.count() == 0 delete_alias(alias, user) assert DomainDeletedAlias.count() == 1 # create the same alias, should return error suffix = f"@{domain}" alias_suffix = AliasSuffix( is_custom=False, suffix=suffix, signed_suffix=signer.sign(suffix).decode(), is_premium=False, domain=EMAIL_DOMAIN, ) r = flask_client.post( url_for("dashboard.custom_alias"), data={ "prefix": "prefix", "signed-alias-suffix": alias_suffix.signed_suffix, "mailboxes": [user.default_mailbox_id], }, follow_redirects=True, ) assert r.status_code == 200 assert "You have deleted this alias before. You can restore it on" in r.get_data( True ) def test_too_many_requests(flask_client): config.DISABLE_RATE_LIMIT = False user = login(flask_client) # create a custom domain domain = random_domain() CustomDomain.create(user_id=user.id, domain=domain, verified=True, commit=True) # can't create more than 5 aliases in 1 minute for i in range(7): signed_suffix = signer.sign(f"@{domain}").decode() r = flask_client.post( url_for("dashboard.custom_alias"), data={ "prefix": f"prefix{i}", "suffix": signed_suffix, "mailboxes": [user.default_mailbox_id], }, follow_redirects=True, ) # to make flask-limiter work with unit test # https://github.com/alisaifee/flask-limiter/issues/147#issuecomment-642683820 g._rate_limiting_complete = False else: # last request assert r.status_code == 429 assert "Whoa, slow down there, pardner!" in str(r.data)