Test invalid statuses and template_types

Run through a few scenarios in the `test_schema_notifications.py`
test file, calling `.validate()` on some data instead of actually
calling the route.

tests/app/v2/notifications/test_get_notifications.py

@@ -156,38 +156,24 @@ def test_get_all_notifications_filter_by_single_status(client, notify_db, notify
     assert json_response['notifications'][0]['status'] == "pending"
 
 
-@pytest.mark.parametrize('invalid_statuses, valid_statuses', [
+def test_get_all_notifications_filter_by_status_invalid_status(client, notify_db, notify_db_session):
-    # one invalid status
-    (["elephant"], []),
-    # multiple invalid statuses
-    (["elephant", "giraffe", "cheetah"], []),
-    # one bad status and one good status
-    (["elephant"], ["created"]),
-])
-def test_get_all_notifications_filter_by_status_invalid_status(
-        client, notify_db, notify_db_session, invalid_statuses, valid_statuses
-):
     notification = create_sample_notification(notify_db, notify_db_session, status="pending")
     create_sample_notification(notify_db, notify_db_session)
 
     auth_header = create_authorization_header(service_id=notification.service_id)
     response = client.get(
-        path='/v2/notifications?{}'.format(
+        path='/v2/notifications?status=elephant',
-            "&".join(["status={}".format(status) for status in invalid_statuses + valid_statuses])
-        ),
         headers=[('Content-Type', 'application/json'), auth_header])
 
     json_response = json.loads(response.get_data(as_text=True))
-    partial_error_message = "is not one of " \
-        "[created, sending, delivered, pending, failed, technical-failure, temporary-failure, permanent-failure]"
 
     assert response.status_code == 400
     assert response.headers['Content-type'] == "application/json"
 
     assert json_response['status_code'] == 400
-    assert len(json_response['errors']) == len(invalid_statuses)
+    assert len(json_response['errors']) == 1
-    for index, invalid_status in enumerate(invalid_statuses):
+    assert json_response['errors'][0]['message'] == "elephant is not one of [created, sending, delivered, " \
-        assert json_response['errors'][index]['message'] == "{} {}".format(invalid_status, partial_error_message)
+        "pending, failed, technical-failure, temporary-failure, permanent-failure]"
 
 
 def test_get_all_notifications_filter_by_multiple_statuses(client, notify_db, notify_db_session):

tests/app/v2/notifications/test_notification_schemas.py

@@ -5,10 +5,80 @@ from flask import json
 from jsonschema import ValidationError
 
 from app.v2.notifications.notification_schemas import (
+    get_notifications_request,
     post_sms_request, post_sms_response, post_email_request, post_email_response
 )
 from app.schema_validation import validate
 
+
+@pytest.mark.parametrize('invalid_statuses, valid_statuses', [
+    # one invalid status
+    (["elephant"], []),
+    # multiple invalid statuses
+    (["elephant", "giraffe", "cheetah"], []),
+    # one bad status and one good status
+    (["elephant"], ["created"]),
+])
+def test_get_notifications_request_invalid_statuses(
+        invalid_statuses, valid_statuses
+):
+    partial_error_status = "is not one of " \
+        "[created, sending, delivered, pending, failed, technical-failure, temporary-failure, permanent-failure]"
+
+    with pytest.raises(ValidationError) as e:
+        validate({'status': invalid_statuses + valid_statuses}, get_notifications_request)
+
+    errors = json.loads(e.value.message).get('errors')
+    assert len(errors) == len(invalid_statuses)
+    for index, value in enumerate(invalid_statuses):
+        assert errors[index]['message'] == "{} {}".format(value, partial_error_status)
+
+
+@pytest.mark.parametrize('invalid_template_types, valid_template_types', [
+    # one invalid template_type
+    (["orange"], []),
+    # multiple invalid template_types
+    (["orange", "avocado", "banana"], []),
+    # one bad template_type and one good template_type
+    (["orange"], ["sms"]),
+])
+def test_get_notifications_request_invalid_template_types(
+        invalid_template_types, valid_template_types
+):
+    partial_error_template_type = "is not one of [sms, email, letter]"
+
+    with pytest.raises(ValidationError) as e:
+        validate({'template_type': invalid_template_types + valid_template_types}, get_notifications_request)
+
+    errors = json.loads(e.value.message).get('errors')
+    assert len(errors) == len(invalid_template_types)
+    for index, value in enumerate(invalid_template_types):
+        assert errors[index]['message'] == "{} {}".format(value, partial_error_template_type)
+
+
+def test_get_notifications_request_invalid_statuses_and_template_types():
+    with pytest.raises(ValidationError) as e:
+        validate({
+            'status': ["created", "elephant", "giraffe"],
+            'template_type': ["sms", "orange", "avocado"]
+        }, get_notifications_request)
+
+    errors = json.loads(e.value.message).get('errors')
+
+    assert len(errors) == 4
+
+    error_messages = [error['message'] for error in errors]
+
+    for invalid_status in ["elephant", "giraffe"]:
+        assert "{} is not one of [created, sending, delivered, " \
+            "pending, failed, technical-failure, temporary-failure, permanent-failure]".format(
+                invalid_status
+            ) in error_messages
+
+    for invalid_template_type in ["orange", "avocado"]:
+        assert "{} is not one of [sms, email, letter]".format(invalid_template_type) in error_messages
+
+
 valid_json = {"phone_number": "07515111111",
               "template_id": str(uuid.uuid4())
               }