def test_emails_are_sequenced_correctly(self):
mail = Mail.objects.create(
edi_filename="something",
edi_data="some data",
extract_type=ExtractTypeEnum.LICENCE_DATA,
status=ReceptionStatusEnum.REPLY_PENDING,
)
LicenceData.objects.create(source_run_number=4, hmrc_run_number=49543, mail=mail, source=SourceEnum.LITE)
mail_lite = serialize_email_message(self.dto_2)
mail_spire = serialize_email_message(self.dto_1)
self.assertEqual(Mail.objects.filter(status=ReceptionStatusEnum.REPLY_RECEIVED).count(), 1)
self.assertEqual(Mail.objects.filter(status=ReceptionStatusEnum.PENDING).count(), 1)
mail = select_email_for_sending()
self.assertEqual(mail_spire, mail)
mail_spire.status = ReceptionStatusEnum.REPLY_SENT
mail_spire.save()
mail = select_email_for_sending()
self.assertEqual(mail_lite, mail)
def test_licence_reply_does_not_throw_exception_if_mail_already_updated(
self):
self.mail.extract_type = ExtractTypeEnum.LICENCE_DATA
self.mail.status = ReceptionStatusEnum.REPLY_SENT
self.mail.save()
response_date = self.mail.response_date
email_message_dto = EmailMessageDto(
run_number=self.hmrc_run_number,
sender=HMRC_ADDRESS,
receiver=EMAIL_USER,
date="Mon, 17 May 2021 14:20:18 +0100",
body="body",
subject=self.licence_data_reply_name,
attachment=[
self.licence_data_reply_name, self.licence_data_reply_body
],
raw_data="qwerty",
)
serialize_email_message(email_message_dto)
self.mail.refresh_from_db()
self.assertEqual(response_date, self.mail.response_date)
def test_usage_data_reply_is_saved(self):
self.mail.status = ReceptionStatusEnum.REPLY_PENDING
self.mail.save()
email_message_dto = EmailMessageDto(
run_number=self.source_run_number + 1,
sender=SPIRE_ADDRESS,
receiver=HMRC_ADDRESS,
date="Mon, 17 May 2021 14:20:18 +0100",
body="body",
subject=self.usage_data_reply_name,
attachment=[
self.usage_data_reply_name, self.usage_data_reply_body
],
raw_data="qwerty",
)
serialize_email_message(email_message_dto)
self.mail.refresh_from_db()
self.assertEqual(self.mail.status, ReceptionStatusEnum.REPLY_RECEIVED)
self.assertIsNotNone(self.mail.response_date)
self.assertIn(
self.mail.response_data,
self.usage_data_reply_body.decode("utf-8"),
)
def test_retry(self):
serialize_email_message(self.dto_2)
mail_count = Mail.objects.count()
licence_data_count = LicenceData.objects.count()
mail = serialize_email_message(self.dto_2)
mail.response_data = "rejected"
mail.save()
serialize_email_message(self.dto_2)
self.assertEqual(Mail.objects.count(), mail_count + 1)
self.assertEqual(LicenceData.objects.count(), licence_data_count + 1)
def check_and_route_emails():
logger.info("Checking for emails")
hmrc_to_dit_server = get_hmrc_to_dit_mailserver()
email_message_dtos = _get_email_message_dtos(hmrc_to_dit_server, number=None)
email_message_dtos = sort_dtos_by_date(email_message_dtos)
logging.info("Incoming message dtos sorted by date: %s" % email_message_dtos)
spire_to_dit_server = get_spire_to_dit_mailserver()
if hmrc_to_dit_server != spire_to_dit_server:
# if the config for the return path is different to outgoing mail path
# then check the return path otherwise don't bother as it will contain the
# same emails.
reply_message_dtos = _get_email_message_dtos(spire_to_dit_server)
reply_message_dtos = sort_dtos_by_date(reply_message_dtos)
logging.info("Reply message dtos sorted by date: %s" % reply_message_dtos)
email_message_dtos.extend(reply_message_dtos)
if not email_message_dtos:
pending_message = check_for_pending_messages()
if pending_message:
logging.info(
f"Found pending mail ({pending_message.id}) of extract type {pending_message.extract_type} for sending"
)
_collect_and_send(pending_message)
logger.info(f"No new emails found from {hmrc_to_dit_server.user} or {spire_to_dit_server.user}")
publish_queue_status()
return
for email, mark_status in email_message_dtos:
try:
logging.info(f"Processing mail with subject {email.subject}")
serialize_email_message(email)
mark_status(MailReadStatuses.READ)
except ValidationError as ve:
logger.info(f"Marking message {email.subject} as UNPROCESSABLE. {ve.detail}")
mark_status(MailReadStatuses.UNPROCESSABLE)
logger.info("Finished checking for emails")
mail = select_email_for_sending() # Can return None in the event of in flight or no pending or no reply_received
if mail:
logging.info(
f"Selected mail ({mail.id}) for sending, extract type {mail.extract_type}, current status {mail.status}"
)
_collect_and_send(mail)
publish_queue_status()
def test_duplicate_emails_and_licence_datas_not_saved(self):
mail = Mail.objects.create(
edi_filename=self.dto_2.attachment[0],
edi_data=self.dto_2.attachment[1],
extract_type=ExtractTypeEnum.LICENCE_DATA,
status=ReceptionStatusEnum.REPLY_SENT,
)
LicenceData.objects.create(source_run_number=17, hmrc_run_number=49542, mail=mail, source=SourceEnum.SPIRE)
mail_count = Mail.objects.count()
licence_data_count = LicenceData.objects.count()
serialize_email_message(self.dto_3)
self.assertEqual(mail_count, Mail.objects.count() - 1)
self.assertEqual(licence_data_count, LicenceData.objects.count())
def test_licence_data_reply_is_saved(self):
self.mail.extract_type = ExtractTypeEnum.LICENCE_DATA
self.mail.status = ReceptionStatusEnum.REPLY_PENDING
self.mail.save()
email_message_dto = EmailMessageDto(
run_number=self.source_run_number + 1,
sender=HMRC_ADDRESS,
receiver=SPIRE_ADDRESS,
date="Mon, 17 May 2021 14:20:18 +0100",
body="body",
subject=self.licence_data_reply_name,
attachment=[
self.licence_data_reply_name,
self.licence_data_reply_body,
],
raw_data="qwerty",
)
serialize_email_message(email_message_dto)
self.mail.refresh_from_db()
logging.debug("resp data: {}".format(self.mail.response_data))
self.assertEqual(self.mail.status, ReceptionStatusEnum.REPLY_RECEIVED)
self.assertIsNotNone(self.mail.response_date)