Merge pull request #98 from alphagov/invite-user-2

[WIP] added dao and rest endpoint for retrieving invited users

app/dao/invited_user_dao.py

@@ -1,6 +1,16 @@
 from app import db
 
+from app.models import InvitedUser
+
 
 def save_invited_user(invited_user):
     db.session.add(invited_user)
     db.session.commit()
+
+
+def get_invited_user(service_id, invited_user_id):
+    return InvitedUser.query.filter_by(service_id=service_id, id=invited_user_id).first()
+
+
+def get_invited_users_for_service(service_id):
+    return InvitedUser.query.filter_by(service_id=service_id).all()

app/invite/rest.py

@@ -4,8 +4,16 @@ from flask import (
     jsonify
 )
 
-from app.dao.invited_user_dao import save_invited_user
-from app.schemas import invited_user_schema
+from app.dao.invited_user_dao import (
+    save_invited_user,
+    get_invited_user,
+    get_invited_users_for_service
+)
+
+from app.schemas import (
+    invited_user_schema,
+    invited_users_schema
+)
 
 invite = Blueprint('invite', __name__, url_prefix='/service/<service_id>/invite')
 
@@ -14,11 +22,25 @@ register_errors(invite)
 
 
 @invite.route('', methods=['POST'])
-def create_invite_user(service_id):
+def create_invited_user(service_id):
     invited_user, errors = invited_user_schema.load(request.get_json())
     if errors:
         return jsonify(result="error", message=errors), 400
-
     save_invited_user(invited_user)
-
     return jsonify(data=invited_user_schema.dump(invited_user).data), 201
+
+
+@invite.route('', methods=['GET'])
+def get_invited_users_by_service(service_id):
+    invited_users = get_invited_users_for_service(service_id)
+    return jsonify(data=invited_users_schema.dump(invited_users).data), 200
+
+
+@invite.route('/<invited_user_id>', methods=['GET'])
+def get_invited_user_by_service_and_id(service_id, invited_user_id):
+    invited_user = get_invited_user(service_id, invited_user_id)
+    if not invited_user:
+        message = 'Invited user not found for service id: {} and invited user id: {}'.format(service_id,
+                                                                                             invited_user_id)
+        return jsonify(result='error', message=message), 404
+    return jsonify(data=invited_user_schema.dump(invited_user).data), 200

tests/app/conftest.py

@@ -1,13 +1,14 @@
 import pytest
 
 from app import email_safe
-from app.models import (User, Service, Template, ApiKey, Job, Notification)
+from app.models import (User, Service, Template, ApiKey, Job, Notification, InvitedUser)
 from app.dao.users_dao import (save_model_user, create_user_code, create_secret_code)
 from app.dao.services_dao import dao_create_service
 from app.dao.templates_dao import save_model_template
 from app.dao.api_key_dao import save_model_api_key
 from app.dao.jobs_dao import save_job
 from app.dao.notifications_dao import save_notification
+from app.dao.invited_user_dao import save_invited_user
 import uuid
 
 
@@ -103,7 +104,7 @@ def sample_service(notify_db,
         user = sample_user(notify_db, notify_db_session)
     data = {
         'name': service_name,
-        'users': [user],
+        'users': [],
         'limit': 1000,
         'active': False,
         'restricted': False,
@@ -268,3 +269,26 @@ def mock_celery_send_email_code(mocker):
 @pytest.fixture(scope='function')
 def mock_encryption(mocker):
     return mocker.patch('app.encryption.encrypt', return_value="something_encrypted")
+
+
+@pytest.fixture(scope='function')
+def sample_invited_user(notify_db,
+                        notify_db_session,
+                        service=None,
+                        to_email_address=None):
+
+    if service is None:
+        service = sample_service(notify_db, notify_db_session)
+    if to_email_address is None:
+        to_email_address = 'invited_user@digital.gov.uk'
+
+    from_user = service.users[0]
+
+    data = {
+        'service': service,
+        'email_address': to_email_address,
+        'from_user': from_user
+    }
+    invited_user = InvitedUser(**data)
+    save_invited_user(invited_user)
+    return invited_user

tests/app/dao/test_invited_user_dao.py

@@ -1,7 +1,12 @@
+import uuid
 
 from app.models import InvitedUser
 
-from app.dao.invited_user_dao import save_invited_user
+from app.dao.invited_user_dao import (
+    save_invited_user,
+    get_invited_user,
+    get_invited_users_for_service
+)
 
 
 def test_create_invited_user(notify_db, notify_db_session, sample_service):
@@ -21,3 +26,40 @@ def test_create_invited_user(notify_db, notify_db_session, sample_service):
     assert InvitedUser.query.count() == 1
     assert invited_user.email_address == email_address
     assert invited_user.from_user == invite_from
+
+
+def test_get_invited_user(notify_db, notify_db_session, sample_invited_user):
+    from_db = get_invited_user(sample_invited_user.service.id, sample_invited_user.id)
+    assert from_db == sample_invited_user
+
+
+def test_get_unknown_invited_user_returns_none(notify_db, notify_db_session, sample_service):
+    unknown_id = uuid.uuid4()
+
+    unknown = get_invited_user(sample_service.id, unknown_id)
+    assert unknown is None
+
+
+def test_get_invited_users_for_service(notify_db, notify_db_session, sample_service):
+
+    from tests.app.conftest import sample_invited_user
+    invites = []
+    for i in range(0, 5):
+        email = 'invited_user_{}@service.gov.uk'.format(i)
+
+        invited_user = sample_invited_user(notify_db,
+                                           notify_db_session,
+                                           sample_service,
+                                           email)
+        invites.append(invited_user)
+
+    all_from_db = get_invited_users_for_service(sample_service.id)
+    assert len(all_from_db) == 5
+    for invite in invites:
+        assert invite in all_from_db
+
+
+def test_get_invited_users_for_service_that_has_no_invites(notify_db, notify_db_session, sample_service):
+
+    invites = get_invited_users_for_service(sample_service.id)
+    assert len(invites) == 0

tests/app/invite/test_invite_rest.py

@@ -1,4 +1,5 @@
 import json
+import uuid
 
 from tests import create_authorization_header
 
@@ -68,3 +69,107 @@ def test_create_invited_user_invalid_email(notify_api, sample_service):
             json_resp = json.loads(response.get_data(as_text=True))
             assert json_resp['result'] == 'error'
             assert json_resp['message'] == {'email_address': ['Invalid email']}
+
+
+def test_get_all_invited_users_by_service(notify_api, notify_db, notify_db_session, sample_service):
+
+    from tests.app.conftest import sample_invited_user
+    invites = []
+    for i in range(0, 5):
+        email = 'invited_user_{}@service.gov.uk'.format(i)
+
+        invited_user = sample_invited_user(notify_db,
+                                           notify_db_session,
+                                           sample_service,
+                                           email)
+        invites.append(invited_user)
+
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+
+            url = '/service/{}/invite'.format(sample_service.id)
+
+            auth_header = create_authorization_header(
+                path=url,
+                method='GET'
+            )
+
+            response = client.get(
+                url,
+                headers=[('Content-Type', 'application/json'), auth_header]
+            )
+            assert response.status_code == 200
+            json_resp = json.loads(response.get_data(as_text=True))
+
+            invite_from = sample_service.users[0]
+
+            for invite in json_resp['data']:
+                assert invite['service'] == str(sample_service.id)
+                assert invite['from_user'] == invite_from.id
+                assert invite['id']
+
+
+def test_get_invited_users_by_service_with_no_invites(notify_api, notify_db, notify_db_session, sample_service):
+
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+
+            url = '/service/{}/invite'.format(sample_service.id)
+
+            auth_header = create_authorization_header(
+                path=url,
+                method='GET'
+            )
+
+            response = client.get(
+                url,
+                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']) == 0
+
+
+def test_get_invited_user_by_service_and_id(notify_api, sample_service, sample_invited_user):
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+
+            url = '/service/{}/invite/{}'.format(sample_service.id, sample_invited_user.id)
+
+            auth_header = create_authorization_header(
+                path=url,
+                method='GET'
+            )
+
+            response = client.get(
+                url,
+                headers=[('Content-Type', 'application/json'), auth_header]
+            )
+            assert response.status_code == 200
+            json_resp = json.loads(response.get_data(as_text=True))
+
+            invite_email_address = sample_invited_user.email_address
+            invite_from = sample_service.users[0]
+
+            assert json_resp['data']['service'] == str(sample_service.id)
+            assert json_resp['data']['email_address'] == invite_email_address
+            assert json_resp['data']['from_user'] == invite_from.id
+            assert json_resp['data']['id']
+
+
+def test_get_invited_user_by_service_but_unknown_invite_id_returns_404(notify_api, sample_service):
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+            unknown_id = uuid.uuid4()
+            url = '/service/{}/invite/{}'.format(sample_service.id, unknown_id)
+
+            auth_header = create_authorization_header(
+                path=url,
+                method='GET'
+            )
+
+            response = client.get(
+                url,
+                headers=[('Content-Type', 'application/json'), auth_header]
+            )
+            assert response.status_code == 404