def test_find_new_pending_fcm_notification(self, mock_request):
# Given
last_known_pending = {
"blocks": {
"pending_1": {
"amount": "10000000000000000000000000000000000",
"source": "nano_account"
}
}
}
new_pendings = copy.deepcopy(last_known_pending)
new_pendings['blocks']['pending_2'] = {
"amount": "20000000000000000000000000000000000",
"source": "nano_account"
}
mock_request.post('http://[::1]:7076',
additional_matcher=match_pending,
text=json.dumps(new_pendings))
mock_request.post('http://localhost/webhook')
# When
with patch('app.nano.FCM_ENABLED', True), patch('app.nano.EMAIL_ENABLED', False),\
patch('app.nano.fcm.send') as mock_send:
check_account_for_new_pending('nano_account',
last_known_pending['blocks'],
['*****@*****.**'],
['http://localhost/webhook'])
# Then
mock_send.assert_called_once_with(
'nano_account', 'Pending 20000.00000 XRB at nano_account')
def test_find_new_pending_webhook(self, mock_request):
# Given
last_known_pending = {
"blocks": {
"pending_1": {
"amount": "10000000000000000000000000000000000",
"source": "nano_account"
}
}
}
new_pendings = copy.deepcopy(last_known_pending)
new_pendings['blocks']['pending_2'] = {
"amount": "20000000000000000000000000000000000",
"source": "nano_account"
}
mock_request.post('http://[::1]:7076',
additional_matcher=match_pending,
text=json.dumps(new_pendings))
mock_request.post('http://localhost/webhook')
# When
with patch('app.nano.WEBHOOK_ENABLED',
True), patch('app.nano.EMAIL_ENABLED', False):
check_account_for_new_pending('nano_account',
last_known_pending['blocks'],
['*****@*****.**'],
['http://localhost/webhook'])
payload = json.loads(mock_request.request_history[1].text)
assert payload['text'] == 'Pending 20000.00000 XRB at nano_account'
assert payload['type'] == 'pending'
assert payload['account'] == 'nano_account'
assert payload['amount'] == 20000
def test_find_new_pending_transactions_none_prior_pending(
self, mock_request):
# Given
last_known_pending = {
"blocks": {
"pending_1": {
"amount": "10000000000000000000000000000000000",
"source": "nano_account"
}
}
}
mock_request.post('http://[::1]:7076',
additional_matcher=match_pending,
text=json.dumps(last_known_pending))
# When
with patch('app.nano.ses.send') as mock_send, patch(
'app.nano.EMAIL_ENABLED', True):
newest_transactions = check_account_for_new_pending(
'nano_account', {}, ['*****@*****.**'])
# Then
mock_send.assert_called_once_with(
'*****@*****.**', 'Pending 10000.00000 XRB at nano_account',
AllStringsIn(['nano_account', '10000.00000</a>XRB']),
'*****@*****.**')
# Then
assert newest_transactions == last_known_pending['blocks']
def test_pending_email_not_sent_when_requests_fails(self, mock_request):
# Given
last_known_pending = {
"blocks": {
"pending_1": {
"amount": "10000000000000000000000000000000000",
"source": "nano_account"
}
}
}
mock_request.post('http://[::1]:7076',
additional_matcher=match_pending,
exc=ConnectTimeout)
# When
with patch('app.nano.ses.send') as mock_send, patch(
'app.nano.EMAIL_ENABLED', True):
check_account_for_new_pending('nano_account',
last_known_pending['blocks'],
['*****@*****.**'])
# Then
mock_send.assert_not_called()
def test_pending_block_is_same_when_requests_fails(self, mock_request):
# Given
last_known_pending = {
"blocks": {
"pending_1": {
"amount": "10000000000000000000000000000000000",
"source": "nano_account"
}
}
}
mock_request.post('http://[::1]:7076',
additional_matcher=match_pending,
exc=ConnectTimeout)
# When
with patch('app.nano.ses.send'), patch('app.nano.EMAIL_ENABLED', True):
newest_transactions = check_account_for_new_pending(
'nano_account', last_known_pending['blocks'],
['*****@*****.**'])
assert newest_transactions == last_known_pending['blocks']
def test_email_not_sent_when_none_pending(self, mock_request):
# Given
last_known_pending = {
"blocks": {
"pending_1": {
"amount": "10000000000000000000000000000000000",
"source": "nano_account"
}
}
}
mock_request.post('http://[::1]:7076',
additional_matcher=match_pending,
text=json.dumps(last_known_pending))
# When
with patch('app.nano.ses.send') as mock_send, patch(
'app.nano.EMAIL_ENABLED', True):
newest_transactions = check_account_for_new_pending(
'nano_account', last_known_pending['blocks'],
['*****@*****.**'])
# Then
mock_send.assert_not_called()
assert newest_transactions == last_known_pending['blocks']
if __name__ == '__main__':
last_known_trans = defaultdict(str)
last_known_pending = defaultdict(dict)
# Initialise pendings before notifying
for subscription in session.query(Subscription):
last_known_pending[subscription.account] = get_pendings(
subscription.account)
while True:
subToEmails = defaultdict(list)
subToWebhooks = defaultdict(list)
logger.info('Loading email subscriptions')
# Map account to emails and HTTP addresses
for subscription in session.query(Subscription):
subToEmails[subscription.account].append(subscription.email)
if subscription.webhook:
subToWebhooks[subscription.account].append(
subscription.webhook)
for account in subToEmails.keys():
logger.info(f'Checking for new transactions for {account}')
emails = subToEmails[account]
webhooks = subToWebhooks[account]
account_last_known_trans = last_known_trans[account]
last_known_trans[account] = check_account_for_new_transactions(
account, account_last_known_trans, emails, webhooks)
last_known_pending[account] = check_account_for_new_pending(
account, last_known_pending[account], emails, webhooks)
time.sleep(TIMEOUT)