def test_reconcile_message(db, config):
from inbox.models.util import reconcile_message
from inbox.sendmail.base import create_draft
from inbox.models.account import Account
from inbox.models.message import Message
from inbox.log import get_logger
log = get_logger()
account = db.session.query(Account).get(ACCOUNT_ID)
draft = create_draft(db.session, account)
assert draft.inbox_uid == draft.public_id, 'draft has incorrect inbox_uid'
inbox_uid = draft.inbox_uid
message = Message()
message.thread_id = THREAD_ID
message.received_date = datetime.utcnow()
message.size = len('')
message.is_draft = True
message.is_read = True
message.sanitized_body = ''
message.snippet = ''
message.inbox_uid = draft.inbox_uid
db.session.add(message)
db.session.commit()
reconcile_message(db.session, log, inbox_uid, message)
assert draft.resolved_message and draft.resolved_message.id == message.id,\
'draft not reconciled correctly'
assert message.public_id != draft.public_id, \
'message has incorrect public_id'
def draft_send_api():
if request.content_type == "message/rfc822":
msg = create_draft_from_mime(g.namespace.account, request.data,
g.db_session)
validate_draft_recipients(msg)
resp = send_raw_mime(g.namespace.account, g.db_session, msg)
return resp
data = request.get_json(force=True)
draft_public_id = data.get('draft_id')
if draft_public_id is not None:
draft = get_draft(draft_public_id, data.get('version'), g.namespace.id,
g.db_session)
schedule_action('delete_draft',
draft,
draft.namespace.id,
g.db_session,
inbox_uid=draft.inbox_uid,
message_id_header=draft.message_id_header)
else:
draft = create_draft(data, g.namespace, g.db_session, syncback=False)
validate_draft_recipients(draft)
resp = send_draft(g.namespace.account, draft, g.db_session)
return resp
def draft_send_api():
data = request.get_json(force=True)
draft_public_id = data.get('draft_id')
if draft_public_id is not None:
draft = get_draft(draft_public_id, data.get('version'), g.namespace.id,
g.db_session)
validate_draft_recipients(draft)
resp = send_draft(g.namespace.account, draft, g.db_session,
schedule_remote_delete=True)
else:
draft = create_draft(data, g.namespace, g.db_session, syncback=False)
validate_draft_recipients(draft)
resp = send_draft(g.namespace.account, draft, g.db_session,
schedule_remote_delete=False)
if resp.status_code == 200:
# At this point, the message has been successfully sent. If there's
# any sort of error in committing the updated state, don't allow it
# to cause the request to fail. Otherwise a client may think their
# message hasn't been sent, when it fact it has.
try:
g.db_session.add(draft)
g.db_session.commit()
except Exception as exc:
g.log.critical('Error committing draft after successful send',
exc_info=True, error=exc)
return resp
def draft_create_api():
data = request.get_json(force=True)
try:
draft = create_draft(data, g.namespace, g.db_session, syncback=True)
g.db_session.add(draft)
g.db_session.commit()
except ActionError as e:
return err(e.error, str(e))
return g.encoder.jsonify(draft)
def test_headers_presence(default_namespace, db):
data = {'subject': 'test draft', 'to': [{'email': '*****@*****.**'}]}
draft = create_draft(data, default_namespace, db.session, False)
assert draft.inbox_uid is not None
assert draft.message_id_header is not None
old_uid = draft.inbox_uid
update_draft(db.session, default_namespace.account, draft,
body="updated body", blocks=[])
assert draft.inbox_uid is not None
assert draft.message_id_header is not None
assert draft.inbox_uid != old_uid
def test_save_update_bad_recipient_draft(db, patch_remote_save_draft,
default_account,
example_bad_recipient_drafts):
# You should be able to save a draft, even if
# the recipient's email is invalid.
from inbox.sendmail.base import create_draft
from inbox.actions.base import save_draft as save_draft_remote
from inbox.models import Account
for example_draft in example_bad_recipient_drafts:
draft = create_draft(example_draft, default_account.namespace,
db.session, syncback=False)
save_draft_remote(default_account.id, draft.id, db.session,
{'version': draft.version})
assert len(patch_remote_save_draft) == 2
def test_headers_presence(default_namespace, db):
data = {'subject': 'test draft', 'to': [{'email': '*****@*****.**'}]}
draft = create_draft(data, default_namespace, db.session, False)
assert draft.inbox_uid is not None
assert draft.message_id_header is not None
old_uid = draft.inbox_uid
update_draft(db.session,
default_namespace.account,
draft,
body="updated body",
blocks=[])
assert draft.inbox_uid is not None
assert draft.message_id_header is not None
assert draft.inbox_uid != old_uid
def test_save_update_bad_recipient_draft(db, patch_remote_save_draft,
default_account,
example_bad_recipient_drafts):
# You should be able to save a draft, even if
# the recipient's email is invalid.
from inbox.sendmail.base import create_draft
from inbox.actions.base import save_draft as save_draft_remote
from inbox.models import Account
for example_draft in example_bad_recipient_drafts:
draft = create_draft(example_draft,
default_account.namespace,
db.session,
syncback=False)
save_draft_remote(default_account.id, draft.id, db.session,
{'version': draft.version})
assert len(patch_remote_save_draft) == 2
def draft_send_api():
if request.content_type == "message/rfc822":
msg = create_draft_from_mime(g.namespace.account, request.data,
g.db_session)
validate_draft_recipients(msg)
resp = send_raw_mime(g.namespace.account, g.db_session, msg)
return resp
data = request.get_json(force=True)
draft_public_id = data.get('draft_id')
if draft_public_id is not None:
draft = get_draft(draft_public_id, data.get('version'), g.namespace.id,
g.db_session)
schedule_action('delete_draft', draft, draft.namespace.id,
g.db_session, inbox_uid=draft.inbox_uid,
message_id_header=draft.message_id_header)
else:
draft = create_draft(data, g.namespace, g.db_session, syncback=False)
validate_draft_recipients(draft)
resp = send_draft(g.namespace.account, draft, g.db_session)
return resp
def draft_create_api():
data = request.get_json(force=True)
draft = create_draft(data, g.namespace, g.db_session, syncback=True)
return g.encoder.jsonify(draft)
def draft_create_api():
data = request.get_json(force=True)
draft = create_draft(data, g.namespace, g.db_session, syncback=True)
return g.encoder.jsonify(draft)
