def test_callback_delivery():
delivery_outbox_repo = DeliveryOutboxRepo(DELIVERY_OUTBOX_REPO_CONF)
use_case = DeliverCallbackUseCase(delivery_outbox_repo)
# clearing test queue
delivery_outbox_repo._unsafe_method__clear()
assert not delivery_outbox_repo.get()
processor = Processor(use_case=use_case)
# testing that iter returns processor
assert processor is iter(processor)
# testing no jobs in the queue
assert next(processor) is None
# testing successful delivery
job = _generate_job(POST_SUCCESS_URL)
delivery_outbox_repo.post_job(job)
assert next(processor) is True
assert next(processor) is None
# testing failed delivery
job = _generate_job(POST_ERROR_URL)
delivery_outbox_repo.post_job(job)
# false means failed to deliver
assert next(processor) is False
_test_retries(processor, 10)
assert next(processor) is None
# testing correct rescheduling order
delivery_outbox_repo.post_job(_generate_job(POST_SUCCESS_URL))
delivery_outbox_repo.post_job(_generate_job(POST_ERROR_URL))
delivery_outbox_repo.post_job(_generate_job(POST_SUCCESS_URL))
assert next(processor) is True
assert next(processor) is False
assert next(processor) is True
_test_retries(processor, 10)
assert next(processor) is None
def get_processor(self):
config = self.app.config
delivery_outbox_repo = repos.DeliveryOutboxRepo(config['DELIVERY_OUTBOX_REPO_CONF'])
use_case = use_cases.DeliverCallbackUseCase(
delivery_outbox_repo=delivery_outbox_repo,
hub_url=config['HUB_URL'],
)
return Processor(use_case=use_case)
def get_processor(self):
config = self.app.config
notifications_repo = repos.NotificationsRepo(config['NOTIFICATIONS_REPO_CONF'])
delivery_outbox_repo = repos.DeliveryOutboxRepo(config['DELIVERY_OUTBOX_REPO_CONF'])
subscriptions_repo = repos.SubscriptionsRepo(config.get('SUBSCRIPTIONS_REPO_CONF'))
use_case = use_cases.DispatchMessageToSubscribersUseCase(
notifications_repo=notifications_repo,
delivery_outbox_repo=delivery_outbox_repo,
subscriptions_repo=subscriptions_repo,
)
return Processor(use_case=use_case)
def get_processor(self):
config = self.app.config
channel_repo = ChannelRepo(config['CHANNEL_REPO_CONF'])
notifications_repo = repos.NotificationsRepo(
config['NOTIFICATIONS_REPO_CONF'])
use_case = use_cases.NewMessagesNotifyUseCase(
receiver=config['JURISDICTION'],
channel_repo=channel_repo,
notifications_repo=notifications_repo,
)
return Processor(use_case=use_case)
def test_processor():
use_case = mock.Mock()
processor = Processor(use_case=use_case)
assert iter(processor) == processor
use_case.execute.return_value = False
assert next(processor) is False
use_case.execute.return_value = True
assert next(processor) is True
use_case.execute.return_value = None
assert next(processor) is None
use_case.execute.return_value = True
use_case.execute.side_effect = Exception('Test')
assert next(processor) is None
def get_processor(self):
config = self.app.config
channel_repo = ChannelRepo(config['CHANNEL_REPO_CONF'])
channel_queue_repo = ChannelQueueRepo(config['CHANNEL_QUEUE_REPO_CONF'])
use_case = use_cases.ProcessMessageUseCase(channel_repo, channel_queue_repo, config['FOREIGN_ENDPOINT_URL'])
return Processor(use_case=use_case)
def get_processor():
delivery_outbox_repo_conf = env_queue_config('PROC_DELIVERY_OUTBOX_REPO')
delivery_outbox_repo = DeliveryOutboxRepo(delivery_outbox_repo_conf)
use_case = DeliverCallbackUseCase(
delivery_outbox_repo=delivery_outbox_repo, )
return Processor(use_case=use_case)
def test():
# testing predicate in url search
delivery_outbox_repo = repos.DeliveryOutboxRepo(DELIVERY_OUTBOX_REPO_CONF)
notifications_repo = repos.NotificationsRepo(NOTIFICATIONS_REPO_CONF)
subscriptions_repo = repos.SubscriptionsRepo(SUBSCRIPTIONS_REPO_CONF)
delivery_outbox_repo._unsafe_method__clear()
notifications_repo._unsafe_method__clear()
subscriptions_repo._unsafe_method__clear()
assert notifications_repo.is_empty()
assert delivery_outbox_repo.is_empty()
assert subscriptions_repo.is_empty()
use_case = DispatchMessageToSubscribersUseCase(notifications_repo, delivery_outbox_repo, subscriptions_repo)
processor = Processor(use_case=use_case)
# testing that iter returns processor
assert iter(processor) is processor
# assert processor has nothing to do
assert next(processor) is None
_fill_subscriptions_repo(subscriptions_repo, SUBSCRIPTIONS)
for prefix, subscriptions in SUBSCRIPTIONS_WITH_COMMON_PREFIXES.items():
_fill_subscriptions_repo(subscriptions_repo, subscriptions)
for s in subscriptions_repo.get_subscriptions_by_pattern(Pattern('aaa.bbb.ccc.ddd')):
print(s.__hash__())
print(s.payload, s.key, s.now, s.data)
# testing that subscriptions repod doesn't have side effect on processor
assert next(processor) is None
# testing callbacks spreading for predicates without common prefixes
for predicate, number_of_subscribers in SUBSCRIPTIONS.items():
# pushing notification
message = _generate_msg_object(predicate=predicate)
notifications_repo.post_job(message)
# test proccessor received notification
assert next(processor) is True
# test processor created correct number of delivery jobs
# each subscriptions group has unique topic/predicate
for i in range(number_of_subscribers):
job = delivery_outbox_repo.get_job()
assert job, f"Call:{i+1}. Predicate:{predicate}"
message_queue_id, payload = job
# test that only direct subscribers received this message
assert payload.get('payload', {}).get('predicate') == predicate
# testing that only correct subscribers will receive notification
url = payload.get('s', '')
assert _is_predicate_in_url(url, predicate), {'url': url, 'predicate': predicate}
assert delivery_outbox_repo.delete(message_queue_id)
# test queue is empty
print(delivery_outbox_repo.get_job())
assert not delivery_outbox_repo.get_job()
# processor completed the job
assert next(processor) is None
for prefix, subscriptions in SUBSCRIPTIONS_WITH_COMMON_PREFIXES.items():
# finding longest predicate in the group + total number of expected
# delivery jobs
expect_jobs = 0
longest_predicate = ""
for predicate, number_of_subscribers in subscriptions.items():
if len(longest_predicate) < len(predicate):
longest_predicate = predicate
expect_jobs += number_of_subscribers
# posting notification
message = _generate_msg_object(predicate=longest_predicate)
assert notifications_repo.post_job(message)
assert next(processor) is True
# testing processor created the correct number of delivery jobs
for i in range(expect_jobs):
job = delivery_outbox_repo.get_job()
assert job
message_queue_id, payload = job
# test that only direct subscribers received this message
assert payload.get('payload', {}).get('predicate') == longest_predicate
# testing that only correct subscribers will receive notification
url = payload.get('s', '')
assert _is_predicate_in_url(url, prefix), {'url': url, 'prefix': prefix}
assert delivery_outbox_repo.delete(message_queue_id)
assert next(processor) is None