def test_get_all_notifications_for_job_filtered_by_status(
notify_api,
notify_db,
notify_db_session,
sample_service,
expected_notification_count,
status_args
):
with notify_api.test_request_context(), notify_api.test_client() as client:
job = create_job(notify_db, notify_db_session, service=sample_service)
create_notification(
notify_db,
notify_db_session,
job=job,
to_field="1",
created_at=datetime.utcnow(),
status=NOTIFICATION_STATUS_TYPES[0],
job_row_number=1
)
response = client.get(
path='/service/{}/job/{}/notifications{}'.format(sample_service.id, job.id, status_args),
headers=[create_authorization_header()]
)
resp = json.loads(response.get_data(as_text=True))
assert len(resp['notifications']) == expected_notification_count
assert response.status_code == 200
def test_should_return_notifications_only_for_this_service(
notify_db, notify_db_session):
service_1 = create_service(notify_db,
notify_db_session,
service_name="one",
email_from="one")
service_2 = create_service(notify_db,
notify_db_session,
service_name="two",
email_from="two")
job_1 = create_job(notify_db, notify_db_session, service=service_1)
job_2 = create_job(notify_db, notify_db_session, service=service_2)
create_notification(notify_db,
notify_db_session,
service=service_1,
job=job_1,
status='created')
create_notification(notify_db,
notify_db_session,
service=service_2,
job=job_2,
status='created')
assert len(dao_get_notification_outcomes_for_job(service_1.id,
job_2.id)) == 0
def test_should_return_notifications_only_for_this_service(notify_db, notify_db_session):
service_1 = create_service(notify_db, notify_db_session, service_name="one", email_from="one")
service_2 = create_service(notify_db, notify_db_session, service_name="two", email_from="two")
job_1 = create_job(notify_db, notify_db_session, service=service_1)
job_2 = create_job(notify_db, notify_db_session, service=service_2)
create_notification(notify_db, notify_db_session, service=service_1, job=job_1, status='created')
create_notification(notify_db, notify_db_session, service=service_2, job=job_2, status='created')
assert len(dao_get_notification_outcomes_for_job(service_1.id, job_2.id)) == 0
def test_should_return_notifications_only_for_this_job(notify_db, notify_db_session, sample_service):
job_1 = create_job(notify_db, notify_db_session, service=sample_service)
job_2 = create_job(notify_db, notify_db_session, service=sample_service)
create_notification(notify_db, notify_db_session, service=sample_service, job=job_1, status='created')
create_notification(notify_db, notify_db_session, service=sample_service, job=job_2, status='created')
results = dao_get_notification_outcomes_for_job(sample_service.id, job_1.id)
assert [(row.count, row.status) for row in results] == [
(1, 'created')
]
def test_should_set_cache_value_as_value_from_database_if_cache_not_set(
key_type, notify_db, notify_db_session, sample_service, mocker):
with freeze_time("2016-01-01 12:00:00.000000"):
for x in range(5):
create_notification(notify_db,
notify_db_session,
service=sample_service)
mocker.patch("app.notifications.validators.redis_store.get",
return_value=None)
mocker.patch("app.notifications.validators.redis_store.set")
check_service_over_daily_message_limit(key_type, sample_service)
app.notifications.validators.redis_store.set.assert_called_with(
str(sample_service.id) + "-2016-01-01-count", 5, ex=3600)
def test_dao_fetch_todays_stats_for_all_services_only_includes_today(notify_db):
with freeze_time("2001-01-01T23:59:00"):
just_before_midnight_yesterday = create_notification(notify_db, None, to_field="1", status="delivered")
with freeze_time("2001-01-02T00:01:00"):
just_after_midnight_today = create_notification(notify_db, None, to_field="2", status="failed")
with freeze_time("2001-01-02T12:00:00"):
stats = dao_fetch_todays_stats_for_all_services().all()
stats = {row.status: row.count for row in stats}
assert "delivered" not in stats
assert stats["failed"] == 1
def test_get_all_notifications_for_job_in_order_of_job_number(notify_api,
notify_db,
notify_db_session,
sample_service):
with notify_api.test_request_context(), notify_api.test_client() as client:
main_job = create_job(notify_db, notify_db_session, service=sample_service)
another_job = create_job(notify_db, notify_db_session, service=sample_service)
notification_1 = create_notification(
notify_db,
notify_db_session,
job=main_job,
to_field="1",
created_at=datetime.utcnow(),
job_row_number=1
)
notification_2 = create_notification(
notify_db,
notify_db_session,
job=main_job,
to_field="2",
created_at=datetime.utcnow(),
job_row_number=2
)
notification_3 = create_notification(
notify_db,
notify_db_session,
job=main_job,
to_field="3",
created_at=datetime.utcnow(),
job_row_number=3
)
create_notification(notify_db, notify_db_session, job=another_job)
auth_header = create_authorization_header()
response = client.get(
path='/service/{}/job/{}/notifications'.format(sample_service.id, main_job.id),
headers=[auth_header])
resp = json.loads(response.get_data(as_text=True))
assert len(resp['notifications']) == 3
assert resp['notifications'][0]['to'] == notification_1.to
assert resp['notifications'][0]['job_row_number'] == notification_1.job_row_number
assert resp['notifications'][1]['to'] == notification_2.to
assert resp['notifications'][1]['job_row_number'] == notification_2.job_row_number
assert resp['notifications'][2]['to'] == notification_3.to
assert resp['notifications'][2]['job_row_number'] == notification_3.job_row_number
assert response.status_code == 200
def test_get_all_notifications_for_job_in_order_of_job_number(
notify_api, notify_db, notify_db_session, sample_service):
with notify_api.test_request_context(), notify_api.test_client() as client:
main_job = create_job(notify_db,
notify_db_session,
service=sample_service)
another_job = create_job(notify_db,
notify_db_session,
service=sample_service)
notification_1 = create_notification(notify_db,
notify_db_session,
job=main_job,
to_field="0412345678",
created_at=datetime.utcnow(),
job_row_number=1)
notification_2 = create_notification(notify_db,
notify_db_session,
job=main_job,
to_field="0412345677",
created_at=datetime.utcnow(),
job_row_number=2)
notification_3 = create_notification(notify_db,
notify_db_session,
job=main_job,
to_field="0412345676",
created_at=datetime.utcnow(),
job_row_number=3)
create_notification(notify_db, notify_db_session, job=another_job)
auth_header = create_authorization_header()
response = client.get(path='/service/{}/job/{}/notifications'.format(
sample_service.id, main_job.id),
headers=[auth_header])
resp = json.loads(response.get_data(as_text=True))
assert len(resp['notifications']) == 3
assert resp['notifications'][0]['to'] == notification_1.to
assert resp['notifications'][0][
'job_row_number'] == notification_1.job_row_number
assert resp['notifications'][1]['to'] == notification_2.to
assert resp['notifications'][1][
'job_row_number'] == notification_2.job_row_number
assert resp['notifications'][2]['to'] == notification_3.to
assert resp['notifications'][2][
'job_row_number'] == notification_3.job_row_number
assert response.status_code == 200
def test_should_set_cache_value_as_value_from_database_if_cache_not_set(
key_type,
notify_db,
notify_db_session,
sample_service,
mocker
):
with freeze_time("2016-01-01 12:00:00.000000"):
for x in range(5):
create_notification(notify_db, notify_db_session, service=sample_service)
mocker.patch('app.notifications.validators.redis_store.get', return_value=None)
mocker.patch('app.notifications.validators.redis_store.set')
check_service_message_limit(key_type, sample_service)
app.notifications.validators.redis_store.set.assert_called_with(
str(sample_service.id) + "-2016-01-01-count", 5, ex=3600
)
def test_get_all_notifications_for_job_returns_csv_format(
client,
notify_db,
notify_db_session,
):
job = create_job(notify_db, notify_db_session)
notification = create_notification(
notify_db,
notify_db_session,
job=job,
job_row_number=1,
created_at=datetime.utcnow(),
)
path = '/service/{}/job/{}/notifications'.format(notification.service.id,
job.id)
response = client.get(path=path,
headers=[create_authorization_header()],
query_string={'format_for_csv': True})
assert response.status_code == 200
resp = json.loads(response.get_data(as_text=True))
assert len(resp['notifications']) == 1
notification = resp['notifications'][0]
assert set(notification.keys()) == \
set(['created_at', 'template_type', 'template_name', 'job_name', 'status', 'row_number', 'recipient'])
def test_check_service_message_limit_over_message_limit_fails(key_type, notify_db, notify_db_session, mocker):
with freeze_time("2016-01-01 12:00:00.000000"):
mocker.patch('app.redis_store.get', return_value=None)
mocker.patch('app.notifications.validators.redis_store.set')
service = create_service(notify_db, notify_db_session, restricted=True, limit=4)
for x in range(5):
create_notification(notify_db, notify_db_session, service=service)
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_called_with(
str(service.id) + "-2016-01-01-count", 5, ex=3600
)
def test_check_service_message_limit_over_message_limit_fails(key_type, notify_db, notify_db_session, mocker):
with freeze_time("2016-01-01 12:00:00.000000"):
mocker.patch('app.redis_store.get', return_value=None)
mocker.patch('app.notifications.validators.redis_store.set')
service = create_service(notify_db, notify_db_session, restricted=True, limit=4)
for x in range(5):
create_notification(notify_db, notify_db_session, service=service)
with pytest.raises(TooManyRequestsError) as e:
check_service_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_called_with(
str(service.id) + "-2016-01-01-count", 5, ex=3600
)
def test_fetch_stats_for_today_only_includes_today(notify_db, notify_db_session, sample_template):
# two created email, one failed email, and one created sms
with freeze_time("2001-01-01T23:59:00"):
just_before_midnight_yesterday = create_notification(notify_db, None, to_field="1", status="delivered")
with freeze_time("2001-01-02T00:01:00"):
just_after_midnight_today = create_notification(notify_db, None, to_field="2", status="failed")
with freeze_time("2001-01-02T12:00:00"):
right_now = create_notification(notify_db, None, to_field="3", status="created")
stats = dao_fetch_todays_stats_for_service(sample_template.service_id)
stats = {row.status: row.count for row in stats}
assert "delivered" not in stats
assert stats["failed"] == 1
assert stats["created"] == 1
def test_get_all_notifications_for_job_filtered_by_status(
client, notify_db, notify_db_session, sample_service,
expected_notification_count, status_args):
job = create_job(notify_db, notify_db_session, service=sample_service)
create_notification(notify_db,
notify_db_session,
job=job,
to_field="1",
created_at=datetime.utcnow(),
status=NOTIFICATION_STATUS_TYPES[0],
job_row_number=1)
response = client.get(path='/service/{}/job/{}/notifications{}'.format(
sample_service.id, job.id, status_args),
headers=[create_authorization_header()])
resp = json.loads(response.get_data(as_text=True))
assert len(resp['notifications']) == expected_notification_count
assert response.status_code == 200
def test_check_service_message_limit_over_message_limit_fails(
key_type, notify_db, notify_db_session, mocker):
with freeze_time("2016-01-01 12:00:00.000000"):
redis_get = mocker.patch("app.redis_store.get",
side_effect=["5", True, None])
redis_set = mocker.patch("app.redis_store.set")
send_notification = mocker.patch(
"app.notifications.validators.send_notification_to_service_users")
service = create_service(notify_db,
notify_db_session,
restricted=True,
limit=4)
for x in range(5):
create_notification(notify_db, notify_db_session, service=service)
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 == []
assert redis_get.call_args_list == [
call(f"{service.id}-2016-01-01-count"),
call(f"nearing-{service.id}-2016-01-01-count"),
call(f"over-{service.id}-2016-01-01-count"),
]
assert redis_set.call_args_list == [
call(f"over-{service.id}-2016-01-01-count",
"2016-01-01T12:00:00",
ex=86400)
]
send_notification.assert_called_once_with(
service_id=service.id,
template_id=current_app.config["REACHED_DAILY_LIMIT_TEMPLATE_ID"],
personalisation={
"service_name": service.name,
"contact_url":
f"{current_app.config['ADMIN_BASE_URL']}/contact",
"message_limit_en": "4",
"message_limit_fr": "4",
},
include_user_fields=["name"],
)
def test_should_return_notifications_only_for_this_job(notify_db,
notify_db_session,
sample_service):
job_1 = create_job(notify_db, notify_db_session, service=sample_service)
job_2 = create_job(notify_db, notify_db_session, service=sample_service)
create_notification(notify_db,
notify_db_session,
service=sample_service,
job=job_1,
status='created')
create_notification(notify_db,
notify_db_session,
service=sample_service,
job=job_2,
status='created')
results = dao_get_notification_outcomes_for_job(sample_service.id,
job_1.id)
assert [(row.count, row.status) for row in results] == [(1, 'created')]
def test_check_service_message_limit_records_nearing_daily_limit(
notify_db, notify_db_session, mocker):
with freeze_time("2016-01-01 12:00:00.000000"):
redis_get = mocker.patch("app.redis_store.get", side_effect=[4, None])
redis_set = mocker.patch("app.redis_store.set")
send_notification = mocker.patch(
"app.notifications.validators.send_notification_to_service_users")
service = create_service(notify_db,
notify_db_session,
restricted=True,
limit=5)
for x in range(4):
create_notification(notify_db, notify_db_session, service=service)
check_service_over_daily_message_limit("normal", service)
assert redis_get.call_args_list == [
call(f"{service.id}-2016-01-01-count"),
call(f"nearing-{service.id}-2016-01-01-count"),
]
assert redis_set.call_args_list == [
call(
f"nearing-{service.id}-2016-01-01-count",
"2016-01-01T12:00:00",
ex=86400,
),
]
send_notification.assert_called_once_with(
service_id=service.id,
template_id=current_app.config["NEAR_DAILY_LIMIT_TEMPLATE_ID"],
personalisation={
"service_name": service.name,
"contact_url":
f"{current_app.config['ADMIN_BASE_URL']}/contact",
"message_limit_en": "5",
"message_limit_fr": "5",
},
include_user_fields=["name"],
)
def test_exception_thrown_by_redis_store_get_should_not_be_fatal(
notify_db,
notify_db_session,
notify_api,
key_type,
mocker):
with freeze_time("2016-01-01 12:00:00.000000"):
mocker.patch('app.notifications.validators.redis_store.redis_store.get', side_effect=Exception("broken redis"))
mocker.patch('app.notifications.validators.redis_store.redis_store.set')
service = create_service(notify_db, notify_db_session, restricted=True, limit=4)
for x in range(5):
create_notification(notify_db, notify_db_session, service=service)
with pytest.raises(TooManyRequestsError) as e:
check_service_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.redis_store.set.assert_called_with(
"{}-2016-01-01-count".format(str(service.id)), 5, 3600, None, False, False
)
def test_dao_fetch_todays_stats_for_all_services_groups_correctly(notify_db, notify_db_session, service_factory):
service1 = service_factory.get("service 1", email_from="service.1")
service2 = service_factory.get("service 2", email_from="service.2")
# service1: 2 sms with status "created" and one "failed", and one email
create_notification(notify_db, notify_db_session, service=service1)
create_notification(notify_db, notify_db_session, service=service1)
create_notification(notify_db, notify_db_session, service=service1, status="failed")
create_notification(
notify_db,
notify_db_session,
service=service1,
template=create_email_template(notify_db, notify_db_session, service=service1),
)
# service2: 1 sms "created"
create_notification(notify_db, notify_db_session, service=service2)
stats = dao_fetch_todays_stats_for_all_services().all()
assert len(stats) == 4
assert ("sms", "created", service1.id, 2) in stats
assert ("sms", "failed", service1.id, 1) in stats
assert ("email", "created", service1.id, 1) in stats
assert ("sms", "created", service2.id, 1) in stats
def test_dao_fetch_todays_stats_for_all_services_can_exclude_from_test_key(notify_db, notify_db_session):
create_notification(notify_db, notify_db_session, key_type=KEY_TYPE_NORMAL)
create_notification(notify_db, notify_db_session, key_type=KEY_TYPE_TEAM)
create_notification(notify_db, notify_db_session, key_type=KEY_TYPE_TEST)
stats = dao_fetch_todays_stats_for_all_services(include_from_test_key=False).all()
assert len(stats) == 1
assert stats[0].count == 2
def test_dao_fetch_todays_stats_for_all_services_includes_all_keys_by_default(notify_db, notify_db_session):
create_notification(notify_db, notify_db_session, key_type=KEY_TYPE_NORMAL)
create_notification(notify_db, notify_db_session, key_type=KEY_TYPE_TEAM)
create_notification(notify_db, notify_db_session, key_type=KEY_TYPE_TEST)
stats = dao_fetch_todays_stats_for_all_services().all()
assert len(stats) == 1
assert stats[0].count == 3
def test_fetch_stats_counts_should_ignore_team_key(
notify_db, notify_db_session, sample_template, sample_api_key, sample_test_api_key, sample_team_api_key
):
# two created email, one failed email, and one created sms
create_notification(notify_db, notify_db_session, api_key_id=sample_api_key.id, key_type=sample_api_key.key_type)
create_notification(
notify_db, notify_db_session, api_key_id=sample_test_api_key.id, key_type=sample_test_api_key.key_type
)
create_notification(
notify_db, notify_db_session, api_key_id=sample_team_api_key.id, key_type=sample_team_api_key.key_type
)
create_notification(notify_db, notify_db_session)
stats = dao_fetch_stats_for_service(sample_template.service_id)
assert len(stats) == 1
assert stats[0].notification_type == "sms"
assert stats[0].status == "created"
assert stats[0].count == 3
def test_fetch_stats_counts_correctly(notify_db, notify_db_session, sample_template, sample_email_template):
# two created email, one failed email, and one created sms
create_notification(notify_db, notify_db_session, template=sample_email_template, status="created")
create_notification(notify_db, notify_db_session, template=sample_email_template, status="created")
create_notification(notify_db, notify_db_session, template=sample_email_template, status="technical-failure")
create_notification(notify_db, notify_db_session, template=sample_template, status="created")
stats = dao_fetch_stats_for_service(sample_template.service_id)
stats = sorted(stats, key=lambda x: (x.notification_type, x.status))
assert len(stats) == 3
assert stats[0].notification_type == "email"
assert stats[0].status == "created"
assert stats[0].count == 2
assert stats[1].notification_type == "email"
assert stats[1].status == "technical-failure"
assert stats[1].count == 1
assert stats[2].notification_type == "sms"
assert stats[2].status == "created"
assert stats[2].count == 1
def test_dao_fetch_todays_stats_for_all_services_includes_all_services(notify_db, notify_db_session, service_factory):
# two services, each with an email and sms notification
service1 = service_factory.get("service 1", email_from="service.1")
service2 = service_factory.get("service 2", email_from="service.2")
create_notification(notify_db, notify_db_session, service=service1)
create_notification(notify_db, notify_db_session, service=service2)
create_notification(
notify_db,
notify_db_session,
service=service1,
template=create_email_template(notify_db, notify_db_session, service=service1),
)
create_notification(
notify_db,
notify_db_session,
service=service2,
template=create_email_template(notify_db, notify_db_session, service=service2),
)
stats = dao_fetch_todays_stats_for_all_services().all()
assert len(stats) == 4
# services are ordered by service id; not explicit on email/sms or status
assert stats == sorted(stats, key=lambda x: x.service_id)
def test_get_jobs_should_return_statistics(notify_db, notify_db_session,
notify_api, sample_service):
now = datetime.utcnow()
earlier = datetime.utcnow() - timedelta(days=1)
job_1 = create_job(notify_db,
notify_db_session,
service=sample_service,
created_at=earlier)
job_2 = create_job(notify_db,
notify_db_session,
service=sample_service,
created_at=now)
create_notification(notify_db,
notify_db_session,
service=sample_service,
job=job_1,
status='created')
create_notification(notify_db,
notify_db_session,
service=sample_service,
job=job_1,
status='created')
create_notification(notify_db,
notify_db_session,
service=sample_service,
job=job_1,
status='created')
create_notification(notify_db,
notify_db_session,
service=sample_service,
job=job_2,
status='sending')
create_notification(notify_db,
notify_db_session,
service=sample_service,
job=job_2,
status='sending')
create_notification(notify_db,
notify_db_session,
service=sample_service,
job=job_2,
status='sending')
with notify_api.test_request_context():
with notify_api.test_client() as client:
path = '/service/{}/job'.format(sample_service.id)
auth_header = create_authorization_header()
response = client.get(path, headers=[auth_header])
assert response.status_code == 200
resp_json = json.loads(response.get_data(as_text=True))
assert len(resp_json['data']) == 2
assert resp_json['data'][0]['id'] == str(job_2.id)
assert {
'status': 'sending',
'count': 3
} in resp_json['data'][0]['statistics']
assert resp_json['data'][1]['id'] == str(job_1.id)
assert {
'status': 'created',
'count': 3
} in resp_json['data'][1]['statistics']
def test_get_job_by_id_should_return_summed_statistics(notify_db,
notify_db_session,
notify_api, sample_job):
job_id = str(sample_job.id)
service_id = sample_job.service.id
create_notification(notify_db,
notify_db_session,
service=sample_job.service,
job=sample_job,
status='created')
create_notification(notify_db,
notify_db_session,
service=sample_job.service,
job=sample_job,
status='created')
create_notification(notify_db,
notify_db_session,
service=sample_job.service,
job=sample_job,
status='created')
create_notification(notify_db,
notify_db_session,
service=sample_job.service,
job=sample_job,
status='sending')
create_notification(notify_db,
notify_db_session,
service=sample_job.service,
job=sample_job,
status='failed')
create_notification(notify_db,
notify_db_session,
service=sample_job.service,
job=sample_job,
status='failed')
create_notification(notify_db,
notify_db_session,
service=sample_job.service,
job=sample_job,
status='failed')
create_notification(notify_db,
notify_db_session,
service=sample_job.service,
job=sample_job,
status='technical-failure') # noqa
create_notification(notify_db,
notify_db_session,
service=sample_job.service,
job=sample_job,
status='temporary-failure') # noqa
create_notification(notify_db,
notify_db_session,
service=sample_job.service,
job=sample_job,
status='temporary-failure') # noqa
with notify_api.test_request_context():
with notify_api.test_client() as client:
path = '/service/{}/job/{}'.format(service_id, job_id)
auth_header = create_authorization_header()
response = client.get(path, headers=[auth_header])
assert response.status_code == 200
resp_json = json.loads(response.get_data(as_text=True))
assert resp_json['data']['id'] == job_id
assert {
'status': 'created',
'count': 3
} in resp_json['data']['statistics']
assert {
'status': 'sending',
'count': 1
} in resp_json['data']['statistics']
assert {
'status': 'failed',
'count': 3
} in resp_json['data']['statistics']
assert {
'status': 'technical-failure',
'count': 1
} in resp_json['data']['statistics']
assert {
'status': 'temporary-failure',
'count': 2
} in resp_json['data']['statistics']
assert resp_json['data']['created_by']['name'] == 'Test User'
def test_get_job_by_id_should_return_summed_statistics(notify_db, notify_db_session, notify_api, sample_job):
job_id = str(sample_job.id)
service_id = sample_job.service.id
create_notification(notify_db, notify_db_session, service=sample_job.service, job=sample_job, status='created')
create_notification(notify_db, notify_db_session, service=sample_job.service, job=sample_job, status='created')
create_notification(notify_db, notify_db_session, service=sample_job.service, job=sample_job, status='created')
create_notification(notify_db, notify_db_session, service=sample_job.service, job=sample_job, status='sending')
create_notification(notify_db, notify_db_session, service=sample_job.service, job=sample_job, status='failed')
create_notification(notify_db, notify_db_session, service=sample_job.service, job=sample_job, status='failed')
create_notification(notify_db, notify_db_session, service=sample_job.service, job=sample_job, status='failed')
create_notification(notify_db, notify_db_session, service=sample_job.service, job=sample_job, status='technical-failure') # noqa
create_notification(notify_db, notify_db_session, service=sample_job.service, job=sample_job, status='temporary-failure') # noqa
create_notification(notify_db, notify_db_session, service=sample_job.service, job=sample_job, status='temporary-failure') # noqa
with notify_api.test_request_context():
with notify_api.test_client() as client:
path = '/service/{}/job/{}'.format(service_id, job_id)
auth_header = create_authorization_header(service_id=sample_job.service.id)
response = client.get(path, headers=[auth_header])
assert response.status_code == 200
resp_json = json.loads(response.get_data(as_text=True))
assert resp_json['data']['id'] == job_id
assert {'status': 'created', 'count': 3} in resp_json['data']['statistics']
assert {'status': 'sending', 'count': 1} in resp_json['data']['statistics']
assert {'status': 'failed', 'count': 3} in resp_json['data']['statistics']
assert {'status': 'technical-failure', 'count': 1} in resp_json['data']['statistics']
assert {'status': 'temporary-failure', 'count': 2} in resp_json['data']['statistics']
assert resp_json['data']['created_by']['name'] == 'Test User'
def test_get_jobs_should_return_statistics(notify_db, notify_db_session, notify_api, sample_service):
now = datetime.utcnow()
earlier = datetime.utcnow() - timedelta(days=1)
job_1 = create_job(notify_db, notify_db_session, service=sample_service, created_at=earlier)
job_2 = create_job(notify_db, notify_db_session, service=sample_service, created_at=now)
create_notification(notify_db, notify_db_session, service=sample_service, job=job_1, status='created')
create_notification(notify_db, notify_db_session, service=sample_service, job=job_1, status='created')
create_notification(notify_db, notify_db_session, service=sample_service, job=job_1, status='created')
create_notification(notify_db, notify_db_session, service=sample_service, job=job_2, status='sending')
create_notification(notify_db, notify_db_session, service=sample_service, job=job_2, status='sending')
create_notification(notify_db, notify_db_session, service=sample_service, job=job_2, status='sending')
with notify_api.test_request_context():
with notify_api.test_client() as client:
path = '/service/{}/job'.format(sample_service.id)
auth_header = create_authorization_header(service_id=str(sample_service.id))
response = client.get(path, headers=[auth_header])
assert response.status_code == 200
resp_json = json.loads(response.get_data(as_text=True))
assert len(resp_json['data']) == 2
assert resp_json['data'][0]['id'] == str(job_2.id)
assert {'status': 'sending', 'count': 3} in resp_json['data'][0]['statistics']
assert resp_json['data'][1]['id'] == str(job_1.id)
assert {'status': 'created', 'count': 3} in resp_json['data'][1]['statistics']
