Merge branch 'master' into integrate_MMG

Conflicts:
	app/notifications/rest.py

tests/app/celery/test_tasks.py

@@ -49,16 +49,16 @@ def firetext_error():
 mmg_error = {'Error': '40', 'Description': 'error'}
 
 
-def test_should_call_delete_successful_notifications_in_task(notify_api, mocker):
-    mocker.patch('app.celery.tasks.delete_successful_notifications_created_more_than_a_day_ago')
+def test_should_call_delete_notifications_more_than_week_in_task(notify_api, mocker):
+    mocker.patch('app.celery.tasks.delete_notifications_created_more_than_a_week_ago')
     delete_successful_notifications()
-    assert tasks.delete_successful_notifications_created_more_than_a_day_ago.call_count == 1
+    assert tasks.delete_notifications_created_more_than_a_week_ago.call_count == 1
 
 
-def test_should_call_delete_failed_notifications_in_task(notify_api, mocker):
-    mocker.patch('app.celery.tasks.delete_failed_notifications_created_more_than_a_week_ago')
+def test_should_call_delete_notifications_more_than_week_in_task(notify_api, mocker):
+    mocker.patch('app.celery.tasks.delete_notifications_created_more_than_a_week_ago')
     delete_failed_notifications()
-    assert tasks.delete_failed_notifications_created_more_than_a_week_ago.call_count == 1
+    assert tasks.delete_notifications_created_more_than_a_week_ago.call_count == 1
 
 
 def test_should_call_delete_codes_on_delete_verify_codes_task(notify_api, mocker):
@@ -74,7 +74,7 @@ def test_should_call_delete_invotations_on_delete_invitations_task(notify_api, m
 
 
 @freeze_time("2016-01-01 11:09:00.061258")
-def test_should_process_sms_job(sample_job, mocker):
+def test_should_process_sms_job(sample_job, mocker, mock_celery_remove_job):
     mocker.patch('app.celery.tasks.s3.get_job_from_s3', return_value=load_example_csv('sms'))
     mocker.patch('app.celery.tasks.send_sms.apply_async')
     mocker.patch('app.encryption.encrypt', return_value="something_encrypted")
@@ -97,7 +97,10 @@ def test_should_process_sms_job(sample_job, mocker):
 
 
 @freeze_time("2016-01-01 11:09:00.061258")
-def test_should_not_process_sms_job_if_would_exceed_send_limits(notify_db, notify_db_session, mocker):
+def test_should_not_process_sms_job_if_would_exceed_send_limits(notify_db,
+                                                                notify_db_session,
+                                                                mocker,
+                                                                mock_celery_remove_job):
     service = sample_service(notify_db, notify_db_session, limit=9)
     job = sample_job(notify_db, notify_db_session, service=service, notification_count=10)
 
@@ -112,9 +115,13 @@ def test_should_not_process_sms_job_if_would_exceed_send_limits(notify_db, notif
     job = jobs_dao.dao_get_job_by_id(job.id)
     assert job.status == 'sending limits exceeded'
     tasks.send_sms.apply_async.assert_not_called()
+    mock_celery_remove_job.assert_not_called()
 
 
-def test_should_not_process_sms_job_if_would_exceed_send_limits_inc_today(notify_db, notify_db_session, mocker):
+def test_should_not_process_sms_job_if_would_exceed_send_limits_inc_today(notify_db,
+                                                                          notify_db_session,
+                                                                          mocker,
+                                                                          mock_celery_remove_job):
     service = sample_service(notify_db, notify_db_session, limit=1)
     job = sample_job(notify_db, notify_db_session, service=service)
 
@@ -131,6 +138,7 @@ def test_should_not_process_sms_job_if_would_exceed_send_limits_inc_today(notify
     assert job.status == 'sending limits exceeded'
     s3.get_job_from_s3.assert_not_called()
     tasks.send_sms.apply_async.assert_not_called()
+    mock_celery_remove_job.assert_not_called()
 
 
 def test_should_not_process_email_job_if_would_exceed_send_limits_inc_today(notify_db, notify_db_session, mocker):
@@ -173,7 +181,10 @@ def test_should_not_process_email_job_if_would_exceed_send_limits(notify_db, not
 
 
 @freeze_time("2016-01-01 11:09:00.061258")
-def test_should_process_sms_job_if_exactly_on_send_limits(notify_db, notify_db_session, mocker):
+def test_should_process_sms_job_if_exactly_on_send_limits(notify_db,
+                                                          notify_db_session,
+                                                          mocker,
+                                                          mock_celery_remove_job):
     service = sample_service(notify_db, notify_db_session, limit=10)
     template = sample_email_template(notify_db, notify_db_session, service=service)
     job = sample_job(notify_db, notify_db_session, service=service, template=template, notification_count=10)
@@ -197,9 +208,10 @@ def test_should_process_sms_job_if_exactly_on_send_limits(notify_db, notify_db_s
          "2016-01-01T11:09:00.061258"),
         queue="bulk-email"
     )
+    mock_celery_remove_job.assert_called_once_with((str(job.id),), queue="remove-job")
 
 
-def test_should_not_create_send_task_for_empty_file(sample_job, mocker):
+def test_should_not_create_send_task_for_empty_file(sample_job, mocker, mock_celery_remove_job):
     mocker.patch('app.celery.tasks.s3.get_job_from_s3', return_value=load_example_csv('empty'))
     mocker.patch('app.celery.tasks.send_sms.apply_async')
 
@@ -212,7 +224,7 @@ def test_should_not_create_send_task_for_empty_file(sample_job, mocker):
 
 
 @freeze_time("2016-01-01 11:09:00.061258")
-def test_should_process_email_job(sample_email_job, mocker):
+def test_should_process_email_job(sample_email_job, mocker, mock_celery_remove_job):
     mocker.patch('app.celery.tasks.s3.get_job_from_s3', return_value=load_example_csv('email'))
     mocker.patch('app.celery.tasks.send_email.apply_async')
     mocker.patch('app.encryption.encrypt', return_value="something_encrypted")
@@ -234,9 +246,13 @@ def test_should_process_email_job(sample_email_job, mocker):
     )
     job = jobs_dao.dao_get_job_by_id(sample_email_job.id)
     assert job.status == 'finished'
+    mock_celery_remove_job.assert_called_once_with((str(job.id),), queue="remove-job")
 
 
-def test_should_process_all_sms_job(sample_job, sample_job_with_placeholdered_template, mocker):
+def test_should_process_all_sms_job(sample_job,
+                                    sample_job_with_placeholdered_template,
+                                    mocker,
+                                    mock_celery_remove_job):
     mocker.patch('app.celery.tasks.s3.get_job_from_s3', return_value=load_example_csv('multiple_sms'))
     mocker.patch('app.celery.tasks.send_sms.apply_async')
     mocker.patch('app.encryption.encrypt', return_value="something_encrypted")
@@ -403,6 +419,32 @@ def test_should_send_email_if_restricted_service_and_valid_email(notify_db, noti
     )
 
 
+def test_should_not_send_email_if_restricted_service_and_invalid_email_address(notify_db, notify_db_session, mocker):
+    user = sample_user(notify_db, notify_db_session)
+    service = sample_service(notify_db, notify_db_session, user=user, restricted=True)
+    template = sample_template(
+        notify_db, notify_db_session, service=service, template_type='email', subject_line='Hello'
+    )
+
+    notification = {
+        "template": template.id,
+        "to": "test@example.com"
+    }
+    mocker.patch('app.encryption.decrypt', return_value=notification)
+    mocker.patch('app.aws_ses_client.send_email')
+
+    notification_id = uuid.uuid4()
+    now = datetime.utcnow()
+    send_sms(
+        service.id,
+        notification_id,
+        "encrypted-in-reality",
+        now.strftime(DATETIME_FORMAT)
+    )
+
+    aws_ses_client.send_email.assert_not_called()
+
+
 def test_should_send_template_to_correct_sms_provider_and_persist_with_job_id(sample_job, mocker):
     notification = {
         "template": sample_job.template.id,

tests/app/conftest.py

@@ -345,6 +345,11 @@ def mock_encryption(mocker):
     return mocker.patch('app.encryption.encrypt', return_value="something_encrypted")
 
 
+@pytest.fixture(scope='function')
+def mock_celery_remove_job(mocker):
+    return mocker.patch('app.celery.tasks.remove_job.apply_async')
+
+
 @pytest.fixture(scope='function')
 def sample_invited_user(notify_db,
                         notify_db_session,

tests/app/dao/test_notification_dao.py

@@ -23,12 +23,13 @@ from app.dao.notifications_dao import (
     get_notification_for_job,
     get_notifications_for_job,
     dao_get_notification_statistics_for_service,
-    delete_successful_notifications_created_more_than_a_day_ago,
-    delete_failed_notifications_created_more_than_a_week_ago,
+    delete_notifications_created_more_than_a_day_ago,
+    delete_notifications_created_more_than_a_week_ago,
     dao_get_notification_statistics_for_service_and_day,
     update_notification_status_by_id,
     update_notification_reference_by_id,
-    update_notification_status_by_reference
+    update_notification_status_by_reference,
+    dao_get_template_statistics_for_service
 )
 
 from tests.app.conftest import sample_job
@@ -700,21 +701,21 @@ def test_update_notification(sample_notification, sample_template):
     assert notification_from_db.status == 'failed'
 
 
-def test_should_delete_sent_notifications_after_one_day(notify_db, notify_db_session):
+def test_should_delete_notifications_after_one_day(notify_db, notify_db_session):
     created_at = datetime.utcnow() - timedelta(hours=24)
     sample_notification(notify_db, notify_db_session, created_at=created_at)
     sample_notification(notify_db, notify_db_session, created_at=created_at)
     assert len(Notification.query.all()) == 2
-    delete_successful_notifications_created_more_than_a_day_ago()
+    delete_notifications_created_more_than_a_day_ago('sent')
     assert len(Notification.query.all()) == 0
 
 
-def test_should_delete_failed_notifications_after_seven_days(notify_db, notify_db_session):
+def test_should_delete_notifications_after_seven_days(notify_db, notify_db_session):
     created_at = datetime.utcnow() - timedelta(hours=24 * 7)
     sample_notification(notify_db, notify_db_session, created_at=created_at, status="failed")
     sample_notification(notify_db, notify_db_session, created_at=created_at, status="failed")
     assert len(Notification.query.all()) == 2
-    delete_failed_notifications_created_more_than_a_week_ago()
+    delete_notifications_created_more_than_a_week_ago('failed')
     assert len(Notification.query.all()) == 0
 
 
@@ -725,7 +726,7 @@ def test_should_not_delete_sent_notifications_before_one_day(notify_db, notify_d
     sample_notification(notify_db, notify_db_session, created_at=valid, to_field="valid")
 
     assert len(Notification.query.all()) == 2
-    delete_successful_notifications_created_more_than_a_day_ago()
+    delete_notifications_created_more_than_a_day_ago('sent')
     assert len(Notification.query.all()) == 1
     assert Notification.query.first().to == 'valid'
 
@@ -736,7 +737,7 @@ def test_should_not_delete_failed_notifications_before_seven_days(notify_db, not
     sample_notification(notify_db, notify_db_session, created_at=expired, status="failed", to_field="expired")
     sample_notification(notify_db, notify_db_session, created_at=valid, status="failed", to_field="valid")
     assert len(Notification.query.all()) == 2
-    delete_failed_notifications_created_more_than_a_week_ago()
+    delete_notifications_created_more_than_a_week_ago('failed')
     assert len(Notification.query.all()) == 1
     assert Notification.query.first().to == 'valid'
 
@@ -886,10 +887,168 @@ def test_successful_notification_inserts_followed_by_failure_does_not_increment_
         db.session.execute('DROP TABLE TEMPLATE_STATISTICS')
         dao_create_notification(failing_notification, sample_template.template_type)
     except Exception as e:
-
         # There should be no additional notification stats or counts
         assert NotificationStatistics.query.count() == 1
         notication_stats = NotificationStatistics.query.filter(
             NotificationStatistics.service_id == sample_template.service.id
         ).first()
         assert notication_stats.sms_requested == 3
+
+
+@freeze_time("2016-03-30")
+def test_get_template_stats_for_service_returns_stats_in_reverse_date_order(sample_template, sample_job):
+
+    template_stats = dao_get_template_statistics_for_service(sample_template.service.id)
+    assert len(template_stats) == 0
+    data = {
+        'to': '+44709123456',
+        'job_id': sample_job.id,
+        'service': sample_template.service,
+        'service_id': sample_template.service.id,
+        'template': sample_template,
+        'template_id': sample_template.id,
+        'created_at': datetime.utcnow()
+    }
+
+    notification = Notification(**data)
+    dao_create_notification(notification, sample_template.template_type)
+
+    # move on one day
+    with freeze_time('2016-03-31'):
+        new_notification = Notification(**data)
+        dao_create_notification(new_notification, sample_template.template_type)
+
+    # move on one more day
+    with freeze_time('2016-04-01'):
+        new_notification = Notification(**data)
+        dao_create_notification(new_notification, sample_template.template_type)
+
+    template_stats = dao_get_template_statistics_for_service(sample_template.service_id)
+    assert len(template_stats) == 3
+    assert template_stats[0].day == date(2016, 4, 1)
+    assert template_stats[1].day == date(2016, 3, 31)
+    assert template_stats[2].day == date(2016, 3, 30)
+
+
+@freeze_time('2016-04-09')
+def test_get_template_stats_for_service_returns_stats_can_limit_number_of_days_returned(sample_template):
+
+    template_stats = dao_get_template_statistics_for_service(sample_template.service.id)
+    assert len(template_stats) == 0
+
+    # make 9 stats records from 1st to 9th April
+    for i in range(1, 10):
+        past_date = '2016-04-0{}'.format(i)
+        with freeze_time(past_date):
+            template_stats = TemplateStatistics(template_id=sample_template.id,
+                                                service_id=sample_template.service_id)
+            db.session.add(template_stats)
+            db.session.commit()
+
+    # Retrieve last week of stats
+    template_stats = dao_get_template_statistics_for_service(sample_template.service_id, limit_days=7)
+    assert len(template_stats) == 7
+    assert template_stats[0].day == date(2016, 4, 9)
+    assert template_stats[6].day == date(2016, 4, 3)
+
+
+@freeze_time('2016-04-09')
+def test_get_template_stats_for_service_returns_stats_returns_all_stats_if_no_limit(sample_template):
+
+    template_stats = dao_get_template_statistics_for_service(sample_template.service.id)
+    assert len(template_stats) == 0
+
+    # make 9 stats records from 1st to 9th April
+    for i in range(1, 10):
+        past_date = '2016-04-0{}'.format(i)
+        with freeze_time(past_date):
+            template_stats = TemplateStatistics(template_id=sample_template.id,
+                                                service_id=sample_template.service_id)
+            db.session.add(template_stats)
+            db.session.commit()
+
+    template_stats = dao_get_template_statistics_for_service(sample_template.service_id)
+    assert len(template_stats) == 9
+    assert template_stats[0].day == date(2016, 4, 9)
+    assert template_stats[8].day == date(2016, 4, 1)
+
+
+@freeze_time('2016-04-30')
+def test_get_template_stats_for_service_returns_results_from_first_day_with_data(sample_template):
+
+    template_stats = dao_get_template_statistics_for_service(sample_template.service.id)
+    assert len(template_stats) == 0
+
+    # make 9 stats records from 1st to 9th April - no data after 10th
+    for i in range(1, 10):
+        past_date = '2016-04-0{}'.format(i)
+        with freeze_time(past_date):
+            template_stats = TemplateStatistics(template_id=sample_template.id,
+                                                service_id=sample_template.service_id)
+            db.session.add(template_stats)
+            db.session.commit()
+
+    # Retrieve one day of stats - read date is 2016-04-30
+    template_stats = dao_get_template_statistics_for_service(sample_template.service_id, limit_days=1)
+    assert len(template_stats) == 1
+    assert template_stats[0].day == date(2016, 4, 9)
+
+    # Retrieve three days of stats
+    template_stats = dao_get_template_statistics_for_service(sample_template.service_id, limit_days=3)
+    assert len(template_stats) == 3
+    assert template_stats[0].day == date(2016, 4, 9)
+    assert template_stats[1].day == date(2016, 4, 8)
+    assert template_stats[2].day == date(2016, 4, 7)
+
+    # Retrieve nine days of stats
+    template_stats = dao_get_template_statistics_for_service(sample_template.service_id, limit_days=9)
+    assert len(template_stats) == 9
+    assert template_stats[0].day == date(2016, 4, 9)
+    assert template_stats[8].day == date(2016, 4, 1)
+
+    # Retrieve with no limit
+    template_stats = dao_get_template_statistics_for_service(sample_template.service_id)
+    assert len(template_stats) == 9
+    assert template_stats[0].day == date(2016, 4, 9)
+    assert template_stats[8].day == date(2016, 4, 1)
+
+
+def test_get_template_stats_for_service_with_limit_if_no_records_returns_empty_list(sample_template):
+    template_stats = dao_get_template_statistics_for_service(sample_template.service.id, limit_days=7)
+    assert len(template_stats) == 0
+
+
+def test_get_template_stats_for_service_for_day_returns_stats_in_template_name_order(sample_service, sample_job):
+
+    from app.dao.templates_dao import dao_create_template
+    from app.models import Template
+
+    template_stats = dao_get_template_statistics_for_service(sample_service.id)
+    assert len(template_stats) == 0
+
+    template_names = ['Aardvark', 'ant', 'zebra', 'walrus', 'Donkey', 'Komodo dragon']
+    for name in template_names:
+        data = {
+            'name': name,
+            'template_type': 'sms',
+            'content': 'blah',
+            'service': sample_service
+        }
+        template = Template(**data)
+        dao_create_template(template)
+
+        notification_data = {
+            'to': '+44709123456',
+            'job_id': sample_job.id,
+            'service': template.service,
+            'service_id': template.service.id,
+            'template': template,
+            'template_id': template.id,
+            'created_at': datetime.utcnow()
+        }
+        notification = Notification(**notification_data)
+        dao_create_notification(notification, template.template_type)
+        template_stats = dao_get_template_statistics_for_service(template.service.id)
+
+    for i, name in enumerate(sorted(template_names, key=str.lower)):
+        assert template_stats[i].template.name == name

tests/app/notifications/test_rest.py

@@ -230,28 +230,34 @@ def test_should_reject_invalid_page_param(notify_api, sample_email_template):
 def test_should_return_pagination_links(notify_api, notify_db, notify_db_session, sample_email_template):
     with notify_api.test_request_context():
         with notify_api.test_client() as client:
-            notify_api.config['PAGE_SIZE'] = 1
+            # Effectively mocking page size
+            original_page_size = notify_api.config['PAGE_SIZE']
+            try:
+                notify_api.config['PAGE_SIZE'] = 1
 
-            create_sample_notification(notify_db, notify_db_session, sample_email_template.service)
-            notification_2 = create_sample_notification(notify_db, notify_db_session, sample_email_template.service)
-            create_sample_notification(notify_db, notify_db_session, sample_email_template.service)
+                create_sample_notification(notify_db, notify_db_session, sample_email_template.service)
+                notification_2 = create_sample_notification(notify_db, notify_db_session, sample_email_template.service)
+                create_sample_notification(notify_db, notify_db_session, sample_email_template.service)
 
-            auth_header = create_authorization_header(
-                service_id=sample_email_template.service_id,
-                path='/notifications',
-                method='GET')
+                auth_header = create_authorization_header(
+                    service_id=sample_email_template.service_id,
+                    path='/notifications',
+                    method='GET')
 
-            response = client.get(
-                '/notifications?page=2',
-                headers=[auth_header])
+                response = client.get(
+                    '/notifications?page=2',
+                    headers=[auth_header])
 
-            notifications = json.loads(response.get_data(as_text=True))
-            assert len(notifications['notifications']) == 1
-            assert notifications['links']['last'] == '/notifications?page=3'
-            assert notifications['links']['prev'] == '/notifications?page=1'
-            assert notifications['links']['next'] == '/notifications?page=3'
-            assert notifications['notifications'][0]['to'] == notification_2.to
-            assert response.status_code == 200
+                notifications = json.loads(response.get_data(as_text=True))
+                assert len(notifications['notifications']) == 1
+                assert notifications['links']['last'] == '/notifications?page=3'
+                assert notifications['links']['prev'] == '/notifications?page=1'
+                assert notifications['links']['next'] == '/notifications?page=3'
+                assert notifications['notifications'][0]['to'] == notification_2.to
+                assert response.status_code == 200
+
+            finally:
+                notify_api.config['PAGE_SIZE'] = original_page_size
 
 
 def test_get_all_notifications_returns_empty_list(notify_api, sample_api_key):
@@ -301,6 +307,41 @@ def test_filter_by_template_type(notify_api, notify_db, notify_db_session, sampl
             assert response.status_code == 200
 
 
+def test_filter_by_multiple_template_types(notify_api,
+                                           notify_db,
+                                           notify_db_session,
+                                           sample_template,
+                                           sample_email_template):
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+
+            notification_1 = create_sample_notification(
+                notify_db,
+                notify_db_session,
+                service=sample_email_template.service,
+                template=sample_template)
+            notification_2 = create_sample_notification(
+                notify_db,
+                notify_db_session,
+                service=sample_email_template.service,
+                template=sample_email_template)
+
+            auth_header = create_authorization_header(
+                service_id=sample_email_template.service_id,
+                path='/notifications',
+                method='GET')
+
+            response = client.get(
+                '/notifications?template_type=sms&template_type=email',
+                headers=[auth_header])
+
+            assert response.status_code == 200
+            notifications = json.loads(response.get_data(as_text=True))
+            assert len(notifications['notifications']) == 2
+            set(['sms', 'email']) == set(
+                [x['template']['template_type'] for x in notifications['notifications']])
+
+
 def test_filter_by_status(notify_api, notify_db, notify_db_session, sample_email_template):
     with notify_api.test_request_context():
         with notify_api.test_client() as client:
@@ -309,8 +350,15 @@ def test_filter_by_status(notify_api, notify_db, notify_db_session, sample_email
                 notify_db,
                 notify_db_session,
                 service=sample_email_template.service,
+                template=sample_email_template,
                 status="delivered")
 
+            notification_2 = create_sample_notification(
+                notify_db,
+                notify_db_session,
+                service=sample_email_template.service,
+                template=sample_email_template)
+
             auth_header = create_authorization_header(
                 service_id=sample_email_template.service_id,
                 path='/notifications',
@@ -326,6 +374,42 @@ def test_filter_by_status(notify_api, notify_db, notify_db_session, sample_email
             assert response.status_code == 200
 
 
+def test_filter_by_multiple_statuss(notify_api,
+                                    notify_db,
+                                    notify_db_session,
+                                    sample_email_template):
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+
+            notification_1 = create_sample_notification(
+                notify_db,
+                notify_db_session,
+                service=sample_email_template.service,
+                template=sample_email_template,
+                status="delivered")
+
+            notification_2 = create_sample_notification(
+                notify_db,
+                notify_db_session,
+                service=sample_email_template.service,
+                template=sample_email_template)
+
+            auth_header = create_authorization_header(
+                service_id=sample_email_template.service_id,
+                path='/notifications',
+                method='GET')
+
+            response = client.get(
+                '/notifications?status=delivered&status=sent',
+                headers=[auth_header])
+
+            assert response.status_code == 200
+            notifications = json.loads(response.get_data(as_text=True))
+            assert len(notifications['notifications']) == 2
+            set(['delivered', 'sent']) == set(
+                [x['status'] for x in notifications['notifications']])
+
+
 def test_filter_by_status_and_template_type(notify_api,
                                             notify_db,
                                             notify_db_session,
@@ -795,7 +879,7 @@ def test_should_not_send_email_if_restricted_and_not_a_service_user(notify_api,
             app.celery.tasks.send_email.apply_async.assert_not_called()
 
             assert response.status_code == 400
-            assert 'Email address not permitted for restricted service' in json_resp['message']['to']
+            assert 'Invalid email address for restricted service' in json_resp['message']['to']
 
 
 def test_should_not_send_email_for_job_if_restricted_and_not_a_service_user(
@@ -831,7 +915,7 @@ def test_should_not_send_email_for_job_if_restricted_and_not_a_service_user(
             app.celery.tasks.send_email.apply_async.assert_not_called()
 
             assert response.status_code == 400
-            assert 'Email address not permitted for restricted service' in json_resp['message']['to']
+            assert 'Invalid email address for restricted service' in json_resp['message']['to']
 
 
 @freeze_time("2016-01-01 11:09:00.061258")

tests/app/template_statistics/test_rest.py

@@ -0,0 +1,136 @@
+import json
+from freezegun import freeze_time
+
+from app import db
+from app.models import TemplateStatistics
+
+from tests import create_authorization_header
+
+
+@freeze_time('2016-04-09')
+def test_get_template_statistics_for_service_for_last_week(notify_api, sample_template):
+
+    # make 9 stats records from 1st to 9th April
+    for i in range(1, 10):
+        past_date = '2016-04-0{}'.format(i)
+        with freeze_time(past_date):
+            template_stats = TemplateStatistics(template_id=sample_template.id,
+                                                service_id=sample_template.service_id)
+            db.session.add(template_stats)
+            db.session.commit()
+
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+
+            auth_header = create_authorization_header(
+                path='/service/{}/template-statistics'.format(sample_template.service_id),
+                method='GET'
+            )
+
+            response = client.get(
+                '/service/{}/template-statistics'.format(sample_template.service_id),
+                headers=[('Content-Type', 'application/json'), auth_header],
+                query_string={'limit_days': 7}
+            )
+
+            assert response.status_code == 200
+            json_resp = json.loads(response.get_data(as_text=True))
+            assert len(json_resp['data']) == 7
+            assert json_resp['data'][0]['day'] == '2016-04-09'
+            assert json_resp['data'][6]['day'] == '2016-04-03'
+
+
+@freeze_time('2016-04-30')
+def test_get_template_statistics_for_service_for_last_actual_week_with_data(notify_api, sample_template):
+
+    # make 9 stats records from 1st to 9th April
+    for i in range(1, 10):
+        past_date = '2016-04-0{}'.format(i)
+        with freeze_time(past_date):
+            template_stats = TemplateStatistics(template_id=sample_template.id,
+                                                service_id=sample_template.service_id)
+            db.session.add(template_stats)
+            db.session.commit()
+
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+
+            auth_header = create_authorization_header(
+                path='/service/{}/template-statistics'.format(sample_template.service_id),
+                method='GET'
+            )
+
+            # Date is frozen at 2016-04-30 and no data written since
+            response = client.get(
+                '/service/{}/template-statistics'.format(sample_template.service_id),
+                headers=[('Content-Type', 'application/json'), auth_header],
+                query_string={'limit_days': 7}
+            )
+
+            assert response.status_code == 200
+            json_resp = json.loads(response.get_data(as_text=True))
+            assert len(json_resp['data']) == 7
+            assert json_resp['data'][0]['day'] == '2016-04-09'
+            assert json_resp['data'][6]['day'] == '2016-04-03'
+
+
+def test_get_all_template_statistics_for_service(notify_api, sample_template):
+
+    # make 9 stats records from 1st to 9th April
+    for i in range(1, 10):
+        past_date = '2016-04-0{}'.format(i)
+        with freeze_time(past_date):
+            template_stats = TemplateStatistics(template_id=sample_template.id,
+                                                service_id=sample_template.service_id)
+            db.session.add(template_stats)
+            db.session.commit()
+
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+
+            auth_header = create_authorization_header(
+                path='/service/{}/template-statistics'.format(sample_template.service_id),
+                method='GET'
+            )
+
+            response = client.get(
+                '/service/{}/template-statistics'.format(sample_template.service_id),
+                headers=[('Content-Type', 'application/json'), auth_header]
+            )
+
+            assert response.status_code == 200
+            json_resp = json.loads(response.get_data(as_text=True))
+            assert len(json_resp['data']) == 9
+            assert json_resp['data'][0]['day'] == '2016-04-09'
+            assert json_resp['data'][8]['day'] == '2016-04-01'
+
+
+def test_get_all_template_statistics_with_bad_limit_arg_returns_400(notify_api, sample_template):
+
+    # make 9 stats records from 1st to 9th April
+    for i in range(1, 10):
+        past_date = '2016-04-0{}'.format(i)
+        with freeze_time(past_date):
+            template_stats = TemplateStatistics(template_id=sample_template.id,
+                                                service_id=sample_template.service_id)
+            db.session.add(template_stats)
+            db.session.commit()
+
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+
+            auth_header = create_authorization_header(
+                path='/service/{}/template-statistics'.format(sample_template.service_id),
+                method='GET'
+            )
+
+            response = client.get(
+                '/service/{}/template-statistics'.format(sample_template.service_id),
+                headers=[('Content-Type', 'application/json'), auth_header],
+                query_string={'limit_days': 'blurk'}
+            )
+
+            assert response.status_code == 400
+            json_resp = json.loads(response.get_data(as_text=True))
+            assert json_resp['result'] == 'error'
+            assert json_resp['message'] == {'limit_days': ['blurk is not an integer']}

tests/app/test_validation.py

@@ -1,65 +0,0 @@
-from app.models import User, Service
-from app.validation import allowed_send_to_number, allowed_send_to_email
-
-
-def test_allowed_send_to_number_returns_true_for_restricted_service_with_same_number():
-    mobile_number = '07524609792'
-    service = _create_service_data(mobile_number)
-    assert allowed_send_to_number(service, mobile_number)
-
-
-def test_allowed_send_to_number_returns_false_for_restricted_service_with_different_number():
-    mobile_number = '00447524609792'
-    service = _create_service_data(mobile_number)
-    assert not allowed_send_to_number(service, '+447344609793')
-
-
-def test_allowed_send_to_number_returns_true_for_unrestricted_service_with_different_number():
-    mobile_number = '+447524609792'
-    service = _create_service_data(mobile_number, False)
-    assert allowed_send_to_number(service, '+447344609793')
-
-
-def test_allowed_send_to_email__returns_true_for_restricted_service_with_same_email():
-    email = 'testing@it.gov.uk'
-    service = _create_service_data(email_address=email)
-    assert allowed_send_to_email(service, email)
-
-
-def test_allowed_send_to_email__returns_false_for_restricted_service_with_different_email():
-    email = 'testing@it.gov.uk'
-    service = _create_service_data(email_address=email)
-    assert not allowed_send_to_email(service, 'another@it.gov.uk')
-
-
-def test_allowed_send_to_email__returns_false_for_restricted_service_with_different_email():
-    email = 'testing@it.gov.uk'
-    service = _create_service_data(email_address=email)
-    assert not allowed_send_to_email(service, 'another@it.gov.uk')
-
-
-def test_allowed_send_to_email__returns_true_for_unrestricted_service_with_different_email():
-    email = 'testing@it.gov.uk'
-    service = _create_service_data(email_address=email, restricted=False)
-    assert allowed_send_to_number(service, 'another@it.gov.uk')
-
-
-def _create_service_data(mobile_number='+447524609792', restricted=True, email_address='test_user@it.gov.uk'):
-    usr = {
-        'name': 'Test User',
-        'email_address': email_address,
-        'password': 'password',
-        'mobile_number': mobile_number,
-        'state': 'active'
-    }
-    user = User(**usr)
-    data = {
-        'name': 'Test service',
-        'limit': 10,
-        'active': False,
-        'restricted': restricted,
-        'email_from': 'test_service@it.gov.uk'
-    }
-    service = Service(**data)
-    service.users = [user]
-    return service