def test_non_empty_inbox(valid_message_dicts):
message_dict = valid_message_dicts[0]
message_dict['status'] = 'received'
message_dict['receiver'] = 'CN'
message_dict['sender'] = 'AU'
m = protocol.Message.from_dict(message_dict)
bc_inbox = mock.Mock()
bc_inbox.get.return_value = (432, m)
message_lake = mock.Mock()
object_acl = mock.Mock()
object_retreival = mock.Mock()
notifications = mock.Mock()
use_case = ProcessMessageUseCase(
'CN',
bc_inbox,
message_lake,
object_acl,
object_retreival,
notifications,
None # this is blockchain repo which won't be used now
)
assert use_case.execute()
assert message_lake.post.called
assert object_acl.post.called
assert object_retreival.post_job.called
assert notifications.post.called
assert bc_inbox.delete.called
def _prepare_use_cases(self):
self.uc = ProcessMessageUseCase(
country=env('IGL_COUNTRY', default='AU'),
bc_inbox_repo=self.bc_inbox_repo,
message_lake_repo=self.message_lake_repo,
object_acl_repo=self.object_acl_repo,
object_retreval_repo=self.object_retrieval_repo,
notifications_repo=self.notifications_repo,
blockchain_outbox_repo=self.blockchain_outbox_repo,
)
def _prepare_use_cases(self):
self.uc = ProcessMessageUseCase(
jurisdiction=env('IGL_JURISDICTION', default='AU'),
bc_inbox_repo=self.bc_inbox_repo,
message_lake_repo=self.message_lake_repo,
object_acl_repo=self.object_acl_repo,
object_retreval_repo=self.object_retrieval_repo,
notifications_repo=self.notifications_repo,
blockchain_outbox_repo=self.blockchain_outbox_repo,
)
def test_repo_exceptions(valid_message_dicts):
message_dict = valid_message_dicts[0]
message_dict['status'] = 'pending'
m = protocol.Message.from_dict(message_dict)
bc_inbox = mock.Mock()
bc_inbox.get.return_value = (432, m)
message_lake = mock.Mock()
object_acl = mock.Mock()
object_retreival = mock.Mock()
notifications = mock.Mock()
message_lake = mock.Mock()
object_acl = mock.Mock()
object_retreival = mock.Mock()
notifications = mock.Mock()
blockchain_outbox = mock.Mock()
use_case = ProcessMessageUseCase(
'CN',
bc_inbox,
message_lake,
object_acl,
object_retreival,
notifications,
blockchain_outbox
)
for repo_method, message_status in {
message_lake.post: 'received',
object_acl.post: 'received',
notifications.post: 'received',
blockchain_outbox.post: 'pending',
object_retreival.post_job: 'received'
}.items():
m.status = message_status
repo_method.reset_mock()
repo_method.side_effect = Exception()
assert not use_case.execute()
repo_method.assert_called()
repo_method.side_effect = None
# test loopback, it's ok, we just don't post it to object_retreval_repo
m.sender = 'CN'
assert use_case.execute()
def test_empty_inbox(valid_message_dicts):
bc_inbox = mock.Mock()
bc_inbox.get.return_value = None
message_lake = mock.Mock()
object_acl = mock.Mock()
object_retreival = mock.Mock()
notifications = mock.Mock()
use_case = ProcessMessageUseCase(
'AU',
bc_inbox,
message_lake,
object_acl,
object_retreival,
notifications,
None # this is blockchain repo which won't be used now
)
assert not use_case.execute() # returns False
assert not message_lake.post.called
assert not object_acl.post.called
assert not object_retreival.post.called
assert not notifications.post.called
assert not bc_inbox.delete.called
def test_repo_exceptions(valid_message_dicts):
message_dict = valid_message_dicts[0]
message_dict['status'] = 'pending'
m = protocol.Message.from_dict(message_dict)
bc_inbox = mock.Mock()
bc_inbox.get.return_value = (432, m)
message_lake = mock.Mock()
object_acl = mock.Mock()
object_retreival = mock.Mock()
notifications = mock.Mock()
message_lake = mock.Mock()
object_acl = mock.Mock()
object_retreival = mock.Mock()
notifications = mock.Mock()
blockchain_outbox = mock.Mock()
# sent scenario
use_case = ProcessMessageUseCase('AU', bc_inbox, message_lake, object_acl,
object_retreival, notifications,
blockchain_outbox)
m.sender = 'AU'
m.receiver = 'CN'
m.status = 'pending'
blockchain_outbox.post.reset_mock()
blockchain_outbox.post.side_effect = Exception()
assert not use_case.execute()
blockchain_outbox.post.assert_called()
blockchain_outbox.post.side_effect = None
# received scenario
use_case = ProcessMessageUseCase('AU', bc_inbox, message_lake, object_acl,
object_retreival, notifications,
blockchain_outbox)
m.sender = 'CN'
m.receiver = 'AU'
for repo_method, message_status in {
message_lake.post: 'received',
object_acl.post: 'received',
notifications.post: 'received',
object_retreival.post_job: 'received',
}.items():
m.status = message_status
repo_method.reset_mock()
repo_method.side_effect = Exception()
assert not use_case.execute()
repo_method.assert_called()
repo_method.side_effect = None
class InboundMessageProcessor(object):
"""
Efficiently iterate over the ProcessMessageUseCase.
"""
def _prepare_bc_inbox_repo(self, conf):
bc_inbox_repo_conf = env_queue_config('PROC_BC_INBOX')
if conf:
bc_inbox_repo_conf.update(conf)
self.bc_inbox_repo = BCInboxRepo(bc_inbox_repo_conf)
def _prepare_message_lake_repo(self, conf):
message_lake_repo_conf = env_s3_config('PROC_MESSAGE_LAKE')
if conf:
message_lake_repo_conf.update(conf)
self.message_lake_repo = MessageLakeRepo(message_lake_repo_conf)
def _prepare_object_acl_repo(self, conf):
object_acl_repo_conf = env_s3_config('PROC_OBJECT_ACL_REPO')
if conf:
object_acl_repo_conf.update(conf)
self.object_acl_repo = ObjectACLRepo(object_acl_repo_conf)
def _prepare_object_retrieval_repo(self, conf):
object_retrieval_repo_conf = env_queue_config('PROC_OBJ_RETR_REPO')
if conf:
object_retrieval_repo_conf.update(conf)
self.object_retrieval_repo = ObjectRetrievalRepo(object_retrieval_repo_conf)
def _prepare_notifications_repo(self, conf):
notifications_repo_conf = env_queue_config('PROC_OBJ_OUTBOX_REPO')
if conf:
notifications_repo_conf.update(conf)
self.notifications_repo = NotificationsRepo(notifications_repo_conf)
def _prepare_channel_outbox_repo(self, conf):
blockchain_outbox_repo_conf = env_postgres_config('PROC_BCH_OUTBOX_REPO')
if conf:
blockchain_outbox_repo_conf.update(conf)
self.blockchain_outbox_repo = ApiOutboxRepo(blockchain_outbox_repo_conf)
def _prepare_use_cases(self):
self.uc = ProcessMessageUseCase(
country=env('IGL_COUNTRY', default='AU'),
bc_inbox_repo=self.bc_inbox_repo,
message_lake_repo=self.message_lake_repo,
object_acl_repo=self.object_acl_repo,
object_retreval_repo=self.object_retrieval_repo,
notifications_repo=self.notifications_repo,
blockchain_outbox_repo=self.blockchain_outbox_repo,
)
def __init__(
self,
bc_inbox_repo_conf=None,
message_lake_repo_conf=None,
object_acl_repo_conf=None,
object_retrieval_repo_conf=None,
notifications_repo_conf=None,
blockchain_outbox_repo_conf=None
):
self._prepare_bc_inbox_repo(bc_inbox_repo_conf)
self._prepare_message_lake_repo(message_lake_repo_conf)
self._prepare_object_acl_repo(object_acl_repo_conf)
self._prepare_object_retrieval_repo(object_retrieval_repo_conf)
self._prepare_notifications_repo(notifications_repo_conf)
self._prepare_channel_outbox_repo(blockchain_outbox_repo_conf)
self._prepare_use_cases()
def __iter__(self):
logger.info("Starting the inbound message processor")
return self
def __next__(self):
try:
result = self.uc.execute()
except Exception as e:
logger.exception(e)
result = None
return result