def test_dao_get_letter_contacts_by_service_id(notify_db_session):
service = create_service()
default_letter_contact = create_letter_contact(
service=service, contact_block='Edinburgh, ED1 1AA')
second_letter_contact = create_letter_contact(
service=service, contact_block='Cardiff, CA1 2DB', is_default=False)
third_letter_contact = create_letter_contact(
service=service, contact_block='London, E1 8QS', is_default=False)
results = dao_get_letter_contacts_by_service_id(service_id=service.id)
assert len(results) == 3
assert default_letter_contact == results[0]
assert third_letter_contact == results[1]
assert second_letter_contact == results[2]
def test_fetch_billing_data_for_today_includes_data_with_the_right_status(
notify_db_session):
service = create_service()
template = create_template(service=service, template_type="email")
for status in ['created', 'technical-failure']:
create_notification(template=template, status=status)
today = convert_utc_to_local_timezone(datetime.utcnow())
results = fetch_billing_data_for_day(today)
assert results == []
for status in ['delivered', 'sending', 'temporary-failure']:
create_notification(template=template, status=status)
results = fetch_billing_data_for_day(today)
assert len(results) == 1
assert results[0].notifications_sent == 3
def test_add_letter_contact_does_not_override_default(notify_db_session):
service = create_service()
add_letter_contact_for_service(service_id=service.id, contact_block='Edinburgh, ED1 1AA', is_default=True)
add_letter_contact_for_service(service_id=service.id, contact_block='Swansea, SN1 3CC', is_default=False)
results = dao_get_letter_contacts_by_service_id(service_id=service.id)
assert len(results) == 2
assert results[0].contact_block == 'Edinburgh, ED1 1AA'
assert results[0].is_default
assert results[1].contact_block == 'Swansea, SN1 3CC'
assert not results[1].is_default
def sample_inbound_numbers(notify_db, notify_db_session, sample_service):
service = create_service(service_name='sample service 2',
check_if_service_exists=True)
inbound_numbers = list()
inbound_numbers.append(create_inbound_number(number='1', provider='mmg'))
inbound_numbers.append(
create_inbound_number(number='2',
provider='mmg',
active=False,
service_id=service.id))
inbound_numbers.append(
create_inbound_number(number='3',
provider='firetext',
service_id=sample_service.id))
return inbound_numbers
def test_fetch_monthly_billing_for_year_adds_data_for_today(notify_db_session):
service = create_service()
template = create_template(service=service, template_type="email")
for i in range(1, 32):
create_ft_billing(utc_date='2018-07-{}'.format(i),
service=service,
template=template,
notification_type='email',
rate=0.162)
create_notification(template=template, status='delivered')
assert db.session.query(FactBilling.bst_date).count() == 31
results = fetch_monthly_billing_for_year(service_id=service.id, year=2018)
assert db.session.query(FactBilling.bst_date).count() == 32
assert len(results) == 2
def test_dao_get_reply_to_by_service_id_does_not_return_archived_reply_tos(notify_db_session):
service = create_service()
create_reply_to_email(service=service, email_address='*****@*****.**')
create_reply_to_email(service=service, email_address='*****@*****.**', is_default=False)
archived_reply_to = create_reply_to_email(
service=service,
email_address='*****@*****.**',
is_default=False,
archived=True
)
results = dao_get_reply_to_by_service_id(service_id=service.id)
assert len(results) == 2
assert archived_reply_to not in results
def test_check_service_message_limit_in_cache_over_message_limit_fails(
notify_db_session, key_type, mocker):
with freeze_time("2016-01-01 12:00:00.000000"):
mocker.patch('app.redis_store.get', return_value=5)
mocker.patch('app.notifications.validators.redis_store.set')
mocker.patch('app.notifications.validators.services_dao')
service = create_service(restricted=True, message_limit=4)
with pytest.raises(TooManyRequestsError) as e:
check_service_over_daily_message_limit(key_type, service)
assert e.value.status_code == 429
assert e.value.message == 'Exceeded send limits (4) for today'
assert e.value.fields == []
app.notifications.validators.redis_store.set.assert_not_called()
assert not app.notifications.validators.services_dao.mock_calls
def test_send_pdf_letter_notification_raises_error_if_service_does_not_have_permission(
notify_db_session,
fake_uuid,
permissions,
):
service = create_service(service_permissions=permissions)
post_data = {
'filename': 'valid.pdf',
'created_by': fake_uuid,
'file_id': fake_uuid,
'postage': 'first'
}
with pytest.raises(BadRequestError):
send_pdf_letter_notification(service.id, post_data)
def test_send_one_off_notification_honors_priority(notify_db_session,
persist_mock, celery_mock):
service = create_service()
template = create_template(service=service)
template.process_type = PRIORITY
post_data = {
'template_id': str(template.id),
'to': '07700 900 001',
'created_by': str(service.created_by_id)
}
send_one_off_notification(service.id, post_data)
assert celery_mock.call_args[1]['queue'] == QueueNames.PRIORITY
def test_dao_get_sms_senders_by_service_id(notify_db_session):
service = create_service()
second_sender = dao_add_sms_sender_for_service(
service_id=service.id,
sms_sender="second",
is_default=False,
inbound_number_id=None,
)
results = dao_get_sms_senders_by_service_id(service_id=service.id)
assert len(results) == 2
for x in results:
if x.is_default:
assert x.sms_sender == "testing"
else:
assert x == second_sender
def test_get_api_key_stats_no_sends(admin_request, notify_db, notify_db_session):
service = create_service(service_name='Service 2')
api_key = create_api_key(service)
api_key_stats = admin_request.get(
'api_key.get_api_key_stats',
api_key_id=api_key.id
)['data']
assert api_key_stats["api_key_id"] == str(api_key.id)
assert api_key_stats["email_sends"] == 0
assert api_key_stats["sms_sends"] == 0
assert api_key_stats["total_sends"] == 0
assert api_key_stats["last_send"] is None
def test_dao_add_sms_sender_for_service_switches_default(notify_db_session):
service = create_service()
new_sms_sender = dao_add_sms_sender_for_service(
service_id=service.id,
sms_sender="new_sms",
is_default=True,
inbound_number_id=None,
)
service_sms_senders = ServiceSmsSender.query.order_by(
ServiceSmsSender.created_at).all()
assert len(service_sms_senders) == 2
assert service_sms_senders[0].sms_sender == "testing"
assert not service_sms_senders[0].is_default
assert service_sms_senders[1] == new_sms_sender
def test_fetch_monthly_notification_statuses_per_service(notify_db_session):
service_one = create_service(service_name='service one', service_id=UUID('e4e34c4e-73c1-4802-811c-3dd273f21da4'))
service_two = create_service(service_name='service two', service_id=UUID('b19d7aad-6f09-4198-8b62-f6cf126b87e5'))
create_ft_notification_status(date(2019, 4, 30), notification_type='letter', service=service_one,
notification_status=NOTIFICATION_DELIVERED)
create_ft_notification_status(date(2019, 3, 1), notification_type='email', service=service_one,
notification_status=NOTIFICATION_SENDING, count=4)
create_ft_notification_status(date(2019, 3, 1), notification_type='email', service=service_one,
notification_status=NOTIFICATION_PENDING, count=1)
create_ft_notification_status(date(2019, 3, 2), notification_type='email', service=service_one,
notification_status=NOTIFICATION_TECHNICAL_FAILURE, count=2)
create_ft_notification_status(date(2019, 3, 7), notification_type='email', service=service_one,
notification_status=NOTIFICATION_FAILED, count=1)
create_ft_notification_status(date(2019, 3, 10), notification_type='letter', service=service_two,
notification_status=NOTIFICATION_PERMANENT_FAILURE, count=1)
create_ft_notification_status(date(2019, 3, 10), notification_type='letter', service=service_two,
notification_status=NOTIFICATION_PERMANENT_FAILURE, count=1)
create_ft_notification_status(date(2019, 3, 13), notification_type='sms', service=service_one,
notification_status=NOTIFICATION_SENT, count=1)
create_ft_notification_status(date(2019, 4, 1), notification_type='letter', service=service_two,
notification_status=NOTIFICATION_TEMPORARY_FAILURE, count=10)
create_ft_notification_status(date(2019, 3, 31), notification_type='letter', service=service_one,
notification_status=NOTIFICATION_DELIVERED)
results = fetch_monthly_notification_statuses_per_service(date(2019, 3, 1), date(2019, 4, 30))
assert len(results) == 6
# column order: date, service_id, service_name, notifaction_type, count_sending, count_delivered,
# count_technical_failure, count_temporary_failure, count_permanent_failure, count_sent
assert [x for x in results[0]] == [date(2019, 3, 1), service_two.id, 'service two', 'letter', 0, 0, 0, 0, 2, 0]
assert [x for x in results[1]] == [date(2019, 3, 1), service_one.id, 'service one', 'email', 5, 0, 3, 0, 0, 0]
assert [x for x in results[2]] == [date(2019, 3, 1), service_one.id, 'service one', 'letter', 0, 1, 0, 0, 0, 0]
assert [x for x in results[3]] == [date(2019, 3, 1), service_one.id, 'service one', 'sms', 0, 0, 0, 0, 0, 1]
assert [x for x in results[4]] == [date(2019, 4, 1), service_two.id, 'service two', 'letter', 0, 0, 0, 10, 0, 0]
assert [x for x in results[5]] == [date(2019, 4, 1), service_one.id, 'service one', 'letter', 0, 1, 0, 0, 0, 0]
def test_archive_letter_contact_does_not_archive_a_template_default_letter_contact(
notify_db_session):
service = create_service()
create_letter_contact(service=service, contact_block='Edinburgh, ED1 1AA')
template_default = create_letter_contact(
service=service, contact_block='Aberdeen, AB12 23X', is_default=False)
create_template(service=service,
template_type='letter',
reply_to=template_default.id)
with pytest.raises(ArchiveValidationError) as e:
archive_letter_contact(service.id, template_default.id)
assert 'You cannot delete the default letter contact block for a template' in str(
e.value)
def test_update_existing_sms_sender_with_inbound_number(notify_db_session):
service = create_service()
inbound_number = create_inbound_number(number='12345',
service_id=service.id)
existing_sms_sender = ServiceSmsSender.query.filter_by(
service_id=service.id).one()
sms_sender = update_existing_sms_sender_with_inbound_number(
service_sms_sender=existing_sms_sender,
sms_sender=inbound_number.number,
inbound_number_id=inbound_number.id)
assert sms_sender.inbound_number_id == inbound_number.id
assert sms_sender.sms_sender == inbound_number.number
assert sms_sender.is_default
def test_create_template_folder_fails_if_parent_id_from_different_service(
admin_request, sample_service):
s1 = create_service(service_name='a')
parent_folder_id = create_template_folder(s1).id
resp = admin_request.post('template_folder.create_template_folder',
service_id=sample_service.id,
_data={
'name': 'bar',
'parent_id': str(parent_folder_id)
},
_expected_status=400)
assert resp['result'] == 'error'
assert resp['message'] == 'parent_id not found'
def test_raises_exception_if_update_would_result_in_no_default_sms_sender(
self, notify_db_session):
service = create_service()
existing_sms_sender = ServiceSmsSender.query.filter_by(
service_id=service.id).one()
with pytest.raises(SmsSenderDefaultValidationException) as e:
dao_update_service_sms_sender(
service_id=service.id,
service_sms_sender_id=existing_sms_sender.id,
is_default=False,
sms_sender="updated")
assert 'You must have at least one SMS sender as the default' in str(
e.value)
def test_delete_notifications_returns_sum_correctly(sample_template):
create_notification(template=sample_template,
created_at=datetime.now() - timedelta(days=8))
create_notification(template=sample_template,
created_at=datetime.now() - timedelta(days=8))
s2 = create_service(service_name='s2')
t2 = create_template(s2, template_type='sms')
create_notification(template=t2,
created_at=datetime.now() - timedelta(days=8))
create_notification(template=t2,
created_at=datetime.now() - timedelta(days=8))
ret = delete_notifications_older_than_retention_by_type('sms', qry_limit=1)
assert ret == 4
def test_add_reply_to_email_address_for_service_creates_another_email_for_service(notify_db_session):
service = create_service()
create_reply_to_email(service=service, email_address="*****@*****.**")
add_reply_to_email_address_for_service(service_id=service.id, email_address='*****@*****.**', is_default=False)
results = dao_get_reply_to_by_service_id(service_id=service.id)
assert len(results) == 2
for x in results:
if x.email_address == '*****@*****.**':
assert x.is_default
elif x.email_address == '*****@*****.**':
assert not x.is_default
else:
raise AssertionError()
def test_get_service_sms_senders_for_service(admin_request, notify_db_session):
service_sms_sender = create_service_sms_sender(service=create_service(),
sms_sender='second',
is_default=False)
response_json = admin_request.get(
'service_sms_sender.get_service_sms_senders_for_service',
service_id=service_sms_sender.service_id,
_expected_status=200)
assert len(response_json) == 2
assert response_json[0]['is_default']
assert response_json[0]['sms_sender'] == current_app.config['FROM_NUMBER']
assert not response_json[1]['is_default']
assert response_json[1]['sms_sender'] == 'second'
def test_can_update_letter_contact(notify_db_session):
service = create_service()
letter_contact = create_letter_contact(service=service,
contact_block='Aberdeen, AB12 23X')
update_letter_contact(service_id=service.id,
letter_contact_id=letter_contact.id,
contact_block='Warwick, W14 TSR',
is_default=True)
updated_letter_contact = ServiceLetterContact.query.get(letter_contact.id)
assert updated_letter_contact.contact_block == 'Warwick, W14 TSR'
assert updated_letter_contact.updated_at
assert updated_letter_contact.is_default
def test_get_services_by_partial_name(notify_db_session):
create_service(service_name="Tadfield Police")
create_service(service_name="Tadfield Air Base")
create_service(service_name="London M25 Management Body")
services_from_db = get_services_by_partial_name("Tadfield")
assert len(services_from_db) == 2
assert sorted([service.name for service in services_from_db]) == [
"Tadfield Air Base",
"Tadfield Police",
]
def sample_invited_user(notify_db_session):
service = create_service(check_if_service_exists=True)
to_email_address = '*****@*****.**'
from_user = service.users[0]
data = {
'service': service,
'email_address': to_email_address,
'from_user': from_user,
'permissions': 'send_messages,manage_service,manage_api_keys',
'folder_permissions': ['folder_1_id', 'folder_2_id'],
}
invited_user = InvitedUser(**data)
save_invited_user(invited_user)
return invited_user
def sample_notification_with_job(notify_db_session):
service = create_service(check_if_service_exists=True)
template = create_template(service=service)
job = create_job(template=template)
return create_notification(template=template,
job=job,
job_row_number=None,
to_field=None,
status='created',
reference=None,
created_at=None,
sent_at=None,
billable_units=1,
personalisation=None,
api_key=None,
key_type=KEY_TYPE_NORMAL)
def sample_email_template(notify_db_session):
user = create_user()
service = create_service(user=user,
service_permissions=[EMAIL_TYPE, SMS_TYPE],
check_if_service_exists=True)
data = {
'name': 'Email Template Name',
'template_type': EMAIL_TYPE,
'content': 'This is a template',
'service': service,
'created_by': user,
'subject': 'Email Subject'
}
template = Template(**data)
dao_create_template(template)
return template
def test_dao_fetch_todays_stats_for_all_services_only_includes_today(notify_db_session):
template = create_template(service=create_service())
with freeze_time('2001-01-01T23:59:00'):
# just_before_midnight_yesterday
create_notification(template=template, to_field='1', status='delivered')
with freeze_time('2001-01-02T00:01:00'):
# just_after_midnight_today
create_notification(template=template, to_field='2', status='failed')
with freeze_time('2001-01-02T12:00:00'):
stats = dao_fetch_todays_stats_for_all_services()
stats = {row.status: row.count for row in stats}
assert 'delivered' not in stats
assert stats['failed'] == 1
def test_dao_add_user_to_service_raises_error_if_adding_folder_permissions_for_a_different_service(
sample_service,
):
user = create_user()
other_service = create_service(service_name='other service')
other_service_folder = create_template_folder(other_service)
folder_permissions = [str(other_service_folder.id)]
assert ServiceUser.query.count() == 2
with pytest.raises(IntegrityError) as e:
dao_add_user_to_service(sample_service, user, folder_permissions=folder_permissions)
db.session.rollback()
assert 'insert or update on table "user_folder_permissions" violates foreign key constraint' in str(e.value)
assert ServiceUser.query.count() == 2
def sample_api_key(notify_db,
notify_db_session,
service=None,
key_type=KEY_TYPE_NORMAL,
name=None):
if service is None:
service = create_service(check_if_service_exists=True)
data = {
'service': service,
'name': name or uuid.uuid4(),
'created_by': service.created_by,
'key_type': key_type
}
api_key = ApiKey(**data)
save_model_api_key(api_key)
return api_key
def test_fetch_billing_data_for_day_is_grouped_by_international(
notify_db_session):
service = create_service()
template = create_template(service=service)
create_notification(template=template,
status='delivered',
international=True)
create_notification(template=template,
status='delivered',
international=False)
today = convert_utc_to_local_timezone(datetime.utcnow())
results = fetch_billing_data_for_day(today)
assert len(results) == 2
assert results[0].notifications_sent == 1
assert results[1].notifications_sent == 1
def test_fetch_billing_data_for_day_is_grouped_by_rate_mulitplier(
notify_db_session):
service = create_service()
template = create_template(service=service)
create_notification(template=template,
status='delivered',
rate_multiplier=1)
create_notification(template=template,
status='delivered',
rate_multiplier=2)
today = convert_utc_to_bst(datetime.utcnow())
results = fetch_billing_data_for_day(today.date())
assert len(results) == 2
assert results[0].notifications_sent == 1
assert results[1].notifications_sent == 1
