First commit

app/__init__.py

@@ -156,6 +156,7 @@ def register_v2_blueprints(application):
     from app.v2.notifications.post_notifications import v2_notification_blueprint as post_notifications
     from app.v2.notifications.get_notifications import v2_notification_blueprint as get_notifications
     from app.v2.template.get_template import v2_template_blueprint as get_template
+    from app.v2.templates.get_templates import v2_templates_blueprint as get_templates
     from app.v2.template.post_template import v2_template_blueprint as post_template
     from app.authentication.auth import requires_auth
 
@@ -165,6 +166,9 @@ def register_v2_blueprints(application):
     get_notifications.before_request(requires_auth)
     application.register_blueprint(get_notifications)
 
+    get_templates.before_request(requires_auth)
+    application.register_blueprint(get_templates)
+
     get_template.before_request(requires_auth)
     application.register_blueprint(get_template)
 

app/models.py

@@ -321,9 +321,8 @@ class Template(db.Model):
         )
 
     def serialize(self):
-
         serialized = {
-            "id": self.id,
+            "id": str(self.id),
             "type": self.template_type,
             "created_at": self.created_at.strftime(DATETIME_FORMAT),
             "updated_at": self.updated_at.strftime(DATETIME_FORMAT) if self.updated_at else None,

app/v2/template/get_template.py

@@ -1,8 +1,5 @@
-import uuid
-
-from flask import jsonify, request
+from flask import jsonify
 from jsonschema.exceptions import ValidationError
-from werkzeug.exceptions import abort
 
 from app import api_user
 from app.dao import templates_dao

app/v2/templates/__init__.py

@@ -0,0 +1,7 @@
+from flask import Blueprint
+
+from app.v2.errors import register_errors
+
+v2_templates_blueprint = Blueprint("v2_templates", __name__, url_prefix='/v2/templates')
+
+register_errors(v2_templates_blueprint)

app/v2/templates/get_templates.py

@@ -0,0 +1,38 @@
+import json
+
+from flask import jsonify, request, current_app, url_for
+from jsonschema.exceptions import ValidationError
+
+from app import api_user
+from app.dao import templates_dao
+from app.schema_validation import validate
+from app.v2.templates import v2_templates_blueprint
+from app.v2.templates.templates_schemas import get_all_template_request
+
+
+@v2_templates_blueprint.route("/", methods=['GET'])
+def get_templates():
+    _data = request.args.to_dict()
+
+    data = validate(_data, get_all_template_request)
+
+    templates = templates_dao.dao_get_all_templates_for_service(
+        api_user.service_id,
+        older_than=data.get('older_than'),
+        page_size=current_app.config.get('API_PAGE_SIZE'))
+
+    def _build_links(templates):
+        _links = {
+            'current': url_for(".get_templates", _external=True, **data),
+        }
+
+        if len(templates):
+            next_query_params = dict(data, older_than=templates[-1].id)
+            _links['next'] = url_for(".get_templates", _external=True, **next_query_params)
+
+        return _links
+
+    return jsonify(
+        templates=[template.serialize() for template in templates],
+        links=_build_links(templates)
+    ), 200

app/v2/templates/templates_schemas.py

@@ -0,0 +1,49 @@
+from app.models import TEMPLATE_TYPES
+from app.schema_validation.definitions import uuid
+from app.v2.template_schema import template
+
+
+get_all_template_request = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "request schema for parameters allowed when getting all templates",
+    "type": "object",
+    "properties": {
+        "type": {"enum": TEMPLATE_TYPES},
+        "older_than": uuid
+    },
+    "additionalProperties": False,
+}
+
+get_all_template_response = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "GET response schema when getting all templates",
+    "type": "object",
+    "properties": {
+        "links": {
+            "type": "object",
+            "properties": {
+                "current": {
+                    "type": "string",
+                    "format": "uri"
+                },
+                "next": {
+                    "type": "string",
+                    "format": "uri"
+                }
+            },
+            "additionalProperties": False,
+            "required": ["current"],
+        },
+        "templates": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "$ref": "#/definitions/template"
+            }
+        }
+    },
+    "required": ["links", "templates"],
+    "definitions": {
+        "template": template
+    }
+}

tests/app/v2/template/test_get_template.py

@@ -1,10 +1,9 @@
 import pytest
-import uuid
 
 from flask import json
 
 from app import DATETIME_FORMAT
-from app.models import EMAIL_TYPE, SMS_TYPE, LETTER_TYPE, TEMPLATE_TYPES
+from app.models import EMAIL_TYPE, TEMPLATE_TYPES
 from tests import create_authorization_header
 from tests.app.db import create_template
 

tests/app/v2/template/test_template_schemas.py

@@ -8,9 +8,7 @@ from app.v2.template.template_schemas import (
     get_template_by_id_response,
     get_template_by_id_request,
     post_template_preview_request,
-    post_template_preview_response,
-    get_all_template_request,
-    get_all_template_response
+    post_template_preview_response
 )
 from app.schema_validation import validate
 from jsonschema.exceptions import ValidationError
@@ -77,74 +75,6 @@ valid_json_post_response_with_optionals = {
     'subject': 'some subject'
 }
 
-valid_json_get_all_response = [
-    {
-        'links': {'self': 'http://some.path', 'next': 'http://some.other.path'},
-        "templates": [
-            {"id": str(uuid.uuid4()), "version": 1, "uri": "http://template/id"},
-            {"id": str(uuid.uuid4()), "version": 2, "uri": "http://template/id"}
-        ]
-    },
-    {
-        'links': {'self': 'http://some.path'},
-        "templates": [{"id": str(uuid.uuid4()), "version": 1, "uri": "http://template/id"}]
-    },
-    {
-        'links': {'self': 'http://some.path'},
-        "templates": []
-    }
-]
-
-invalid_json_get_all_response = [
-    ({
-        'links': {'self': 'invalid_uri'},
-        "templates": [
-            {"id": str(uuid.uuid4()), "version": 1, "uri": "http://template/id"}
-        ]
-    }, ['links invalid_uri is not a valid URI.']),
-    ({
-        'links': {'self': 'http://some.path'},
-        "templates": [
-            {"id": 'invalid_id', "version": 1, "uri": "http://template/id"}
-        ]
-    }, ['templates is not a valid UUID']),
-    ({
-        'links': {'self': 'http://some.path'},
-        "templates": [
-            {"id": str(uuid.uuid4()), "version": 'invalid_version', "uri": "http://template/id"}
-        ]
-    }, ['templates invalid_version is not of type integer']),
-    ({
-        'links': {'self': 'http://some.path'},
-        "templates": [
-            {"id": str(uuid.uuid4()), "version": 1, "uri": "invalid_uri"}
-        ]
-    }, ['templates invalid_uri is not a valid URI.']),
-    ({
-        'links': {'self': 'http://some.path'}
-    }, ['templates is a required property']),
-    ({
-        'links': {'next': 'http://some.other.path'},
-        "templates": [{"id": str(uuid.uuid4()), "version": 1, "uri": "http://template/id"}]
-    }, ['links self is a required property']),
-    ({
-        'links': {'self': 'http://some.path', 'next': 'http://some.other.path'},
-        "templates": [{"version": 1, "uri": "http://template/id"}]
-    }, ['templates id is a required property']),
-    ({
-        'links': {'self': 'http://some.path', 'next': 'http://some.other.path'},
-        "templates": [{"id": str(uuid.uuid4()), "uri": "http://template/id"}]
-    }, ['templates version is a required property']),
-    ({
-        'links': {'self': 'http://some.path', 'next': 'http://some.other.path'},
-        "templates": [{"id": str(uuid.uuid4()), "version": 1}]
-    }, ['templates uri is a required property']),
-    ({
-        'links': {'self': 'http://some.path', 'next': 'http://some.other.path'},
-        "templates": [{"version": 1}]
-    }, ['templates id is a required property', 'templates uri is a required property']),
-]
-
 
 @pytest.mark.parametrize("args", valid_request_args)
 def test_get_template_request_schema_against_valid_args_is_valid(args):
@@ -197,26 +127,3 @@ def test_post_template_preview_response_schema_is_valid(response, template_type)
     response['type'] = template_type
 
     assert validate(response, post_template_preview_response) == response
-
-
-@pytest.mark.parametrize("template_type", TEMPLATE_TYPES)
-def test_get_all_template_request_schema_against_valid_args_is_valid(template_type):
-    data = {'type': template_type}
-    assert validate(data, get_all_template_request) == data
-
-
-@pytest.mark.parametrize("response", valid_json_get_all_response)
-def test_valid_get_all_templates_response_schema_is_valid(response):
-    assert validate(response, get_all_template_response) == response
-
-
-@pytest.mark.parametrize("response,error_messages", invalid_json_get_all_response)
-def test_invalid_get_all_templates_response_schema_is_invalid(response, error_messages):
-    with pytest.raises(ValidationError) as e:
-        validate(response, get_all_template_response)
-    errors = json.loads(str(e.value))
-
-    assert errors['status_code'] == 400
-    assert len(errors['errors']) == len(error_messages)
-    for error in errors['errors']:
-        assert error['message'] in error_messages

tests/app/v2/templates/test_get_templates.py

@@ -0,0 +1,117 @@
+import pytest
+
+from flask import json
+
+from app import DATETIME_FORMAT
+from app.models import EMAIL_TYPE, SMS_TYPE, LETTER_TYPE, TEMPLATE_TYPES
+from tests import create_authorization_header
+from tests.app.db import create_template
+
+
+def test_get_all_templates(client, sample_service):
+    num_templates = 3
+    templates = []
+    for i in range(num_templates):
+        for tmp_type in TEMPLATE_TYPES:
+            templates.append(create_template(sample_service, template_type=tmp_type))
+
+    auth_header = create_authorization_header(service_id=sample_service.id)
+
+    response = client.get(path='/v2/templates/?',
+                          headers=[('Content-Type', 'application/json'), auth_header])
+
+    assert response.headers['Content-type'] == 'application/json'
+
+    json_response = json.loads(response.get_data(as_text=True))
+
+    assert len(json_response['templates']) == num_templates * len(TEMPLATE_TYPES)
+
+    # need to reverse index as get all templates returns list sorted by descending date
+    for i in range(len(json_response['templates'])):
+        reverse_index = len(json_response['templates']) - 1 - i
+        assert json_response['templates'][reverse_index]['id'] == str(templates[i].id)
+        assert json_response['templates'][reverse_index]['body'] == templates[i].content
+        assert json_response['templates'][reverse_index]['type'] == templates[i].template_type
+
+
+@pytest.mark.parametrize("tmp_type", TEMPLATE_TYPES)
+def test_get_all_templates_for_type(client, sample_service, tmp_type):
+    num_templates = 3
+    templates = []
+    for i in range(num_templates):
+        templates.append(create_template(sample_service, template_type=tmp_type))
+
+    auth_header = create_authorization_header(service_id=sample_service.id)
+
+    response = client.get(path='/v2/templates/?type={}'.format(tmp_type),
+                          headers=[('Content-Type', 'application/json'), auth_header])
+
+    assert response.headers['Content-type'] == 'application/json'
+
+    json_response = json.loads(response.get_data(as_text=True))
+
+    assert len(json_response['templates']) == num_templates
+
+    # need to reverse index as get all templates returns list sorted by descending date
+    for i in range(len(json_response['templates'])):
+        reverse_index = len(json_response['templates']) - 1 - i
+        assert json_response['templates'][reverse_index]['id'] == str(templates[i].id)
+        assert json_response['templates'][reverse_index]['body'] == templates[i].content
+        assert json_response['templates'][reverse_index]['type'] == templates[i].template_type
+
+
+@pytest.mark.parametrize("tmp_type", [EMAIL_TYPE, SMS_TYPE])
+def test_get_all_templates_older_than_parameter(client, sample_service, tmp_type):
+    num_templates = 5
+    templates = []
+    for i in range(num_templates):
+        template = create_template(sample_service, template_type=tmp_type)
+        templates.append(template)
+
+    num_templates_older = 3
+
+    # only get the first #num_templates_older templates
+    older_than_id = templates[num_templates_older].id
+
+    auth_header = create_authorization_header(service_id=sample_service.id)
+
+    response = client.get(path='/v2/templates/?type={}&older_than={}'.format(tmp_type, older_than_id),
+                          headers=[('Content-Type', 'application/json'), auth_header])
+
+    assert response.status_code == 200
+    assert response.headers['Content-type'] == 'application/json'
+
+    json_response = json.loads(response.get_data(as_text=True))
+
+    assert len(json_response['templates']) == num_templates_older
+
+    # need to reverse index as get all templates returns list sorted by descending date
+    for i in range(num_templates_older):
+        reverse_index = num_templates_older - 1 - i
+        assert json_response['templates'][reverse_index]['id'] == str(templates[i].id)
+        assert json_response['templates'][reverse_index]['body'] == templates[i].content
+        assert json_response['templates'][reverse_index]['type'] == templates[i].template_type
+
+    assert str(older_than_id) in json_response['links']['current']
+    assert str(templates[0].id) in json_response['links']['next']
+
+
+@pytest.mark.parametrize("tmp_type", [EMAIL_TYPE, SMS_TYPE])
+def test_get_all_templates_none_existent_older_than_parameter(client, sample_service, tmp_type, fake_uuid):
+    num_templates = 2
+    templates = []
+    for i in range(num_templates):
+        template = create_template(sample_service, template_type=tmp_type)
+        templates.append(template)
+
+    auth_header = create_authorization_header(service_id=sample_service.id)
+
+    response = client.get(path='/v2/templates/?type={}&older_than={}'.format(tmp_type, fake_uuid),
+                          headers=[('Content-Type', 'application/json'), auth_header])
+
+    assert response.status_code == 200
+    assert response.headers['Content-type'] == 'application/json'
+
+    json_response = json.loads(response.get_data(as_text=True))
+
+    assert len(json_response['templates']) == 0

tests/app/v2/templates/test_templates_schemas.py

@@ -0,0 +1,142 @@
+import uuid
+
+import pytest
+from flask import json
+
+from app.models import EMAIL_TYPE, SMS_TYPE, TEMPLATE_TYPES
+from app.v2.templates.templates_schemas import (
+    get_all_template_request,
+    get_all_template_response
+)
+from app.schema_validation import validate
+from jsonschema.exceptions import ValidationError
+
+
+valid_json_get_all_response = [
+    {
+        'links': {'current': 'http://some.path', 'next': 'http://some.other.path'},
+        "templates": [
+            {"id": str(uuid.uuid4()), "version": 1, "uri": "http://template/id"},
+            {"id": str(uuid.uuid4()), "version": 2, "uri": "http://template/id"}
+        ]
+    },
+    {
+        'links': {'current': 'http://some.path'},
+        "templates": [{"id": str(uuid.uuid4()), "version": 1, "uri": "http://template/id"}]
+    },
+    {
+        'links': {'current': 'http://some.path'},
+        "templates": []
+    }
+]
+
+invalid_json_get_all_response = [
+    ({
+        'links': {'current': 'invalid_uri'},
+        "templates": [
+            {"id": str(uuid.uuid4()), "version": 1, "uri": "http://template/id"}
+        ]
+    }, ['links invalid_uri is not a valid URI.']),
+    ({
+        'links': {'current': 'http://some.path'},
+        "templates": [
+            {"id": 'invalid_id', "version": 1, "uri": "http://template/id"}
+        ]
+    }, ['templates is not a valid UUID']),
+    ({
+        'links': {'current': 'http://some.path'},
+        "templates": [
+            {"id": str(uuid.uuid4()), "version": 'invalid_version', "uri": "http://template/id"}
+        ]
+    }, ['templates invalid_version is not of type integer']),
+    ({
+        'links': {'current': 'http://some.path'},
+        "templates": [
+            {"id": str(uuid.uuid4()), "version": 1, "uri": "invalid_uri"}
+        ]
+    }, ['templates invalid_uri is not a valid URI.']),
+    ({
+        'links': {'current': 'http://some.path'}
+    }, ['templates is a required property']),
+    ({
+        'links': {'next': 'http://some.other.path'},
+        "templates": [{"id": str(uuid.uuid4()), "version": 1, "uri": "http://template/id"}]
+    }, ['links current is a required property']),
+    ({
+        'links': {'current': 'http://some.path', 'next': 'http://some.other.path'},
+        "templates": [{"version": 1, "uri": "http://template/id"}]
+    }, ['templates id is a required property']),
+    ({
+        'links': {'current': 'http://some.path', 'next': 'http://some.other.path'},
+        "templates": [{"id": str(uuid.uuid4()), "uri": "http://template/id"}]
+    }, ['templates version is a required property']),
+    ({
+        'links': {'current': 'http://some.path', 'next': 'http://some.other.path'},
+        "templates": [{"id": str(uuid.uuid4()), "version": 1}]
+    }, ['templates uri is a required property']),
+    ({
+        'links': {'current': 'http://some.path', 'next': 'http://some.other.path'},
+        "templates": [{"version": 1}]
+    }, ['templates id is a required property', 'templates uri is a required property']),
+]
+
+
+@pytest.mark.parametrize("template_type", TEMPLATE_TYPES)
+def test_get_all_template_request_schema_against_no_args_is_valid(template_type):
+    data = {}
+    assert validate(data, get_all_template_request) == data
+
+
+@pytest.mark.parametrize("template_type", TEMPLATE_TYPES)
+def test_get_all_template_request_schema_against_valid_args_is_valid(template_type):
+    data = {'type': template_type}
+    assert validate(data, get_all_template_request) == data
+
+
+@pytest.mark.parametrize("template_type", TEMPLATE_TYPES)
+def test_get_all_template_request_schema_against_valid_args_with_optional_is_valid(template_type, fake_uuid):
+    data = {'type': template_type, 'older_than': fake_uuid}
+    assert validate(data, get_all_template_request) == data
+
+
+@pytest.mark.parametrize("template_type", TEMPLATE_TYPES)
+def test_get_all_template_request_schema_against_invalid_args_is_invalid(template_type):
+    data = {'type': 'unknown'}
+
+    with pytest.raises(ValidationError) as e:
+        validate(data, get_all_template_request)
+    errors = json.loads(str(e.value))
+
+    assert errors['status_code'] == 400
+    assert len(errors['errors']) == 1
+    assert errors['errors'][0]['message'] == 'type unknown is not one of [sms, email, letter]'
+
+
+@pytest.mark.parametrize("template_type", TEMPLATE_TYPES)
+def test_get_all_template_request_schema_against_invalid_args_with_optional_is_invalid(template_type):
+    data = {'type': template_type, 'older_than': 'invalid_uuid'}
+
+    with pytest.raises(ValidationError) as e:
+        validate(data, get_all_template_request)
+    errors = json.loads(str(e.value))
+
+    assert errors['status_code'] == 400
+    assert len(errors['errors']) == 1
+    assert errors['errors'][0]['message'] == 'older_than is not a valid UUID'
+
+
+@pytest.mark.parametrize("response", valid_json_get_all_response)
+def test_valid_get_all_templates_response_schema_is_valid(response):
+    assert validate(response, get_all_template_response) == response
+
+
+@pytest.mark.parametrize("response,error_messages", invalid_json_get_all_response)
+def test_invalid_get_all_templates_response_schema_is_invalid(response, error_messages):
+    with pytest.raises(ValidationError) as e:
+        validate(response, get_all_template_response)
+    errors = json.loads(str(e.value))
+
+    assert errors['status_code'] == 400
+    assert len(errors['errors']) == len(error_messages)
+    for error in errors['errors']:
+        assert error['message'] in error_messages