Merge branch 'master' into forgot-password

Conflicts:
	app/main/views/two_factor.py

app/main/forms.py

@@ -104,7 +104,7 @@ class RegisterUserFromInviteForm(Form):
     mobile_number = mobile_number()
     password = password()
     service = HiddenField('service')
-    email_address = HiddenField('email_address')
+    email_address = email_address()
 
 
 class InviteUserForm(Form):
@@ -127,7 +127,6 @@ class TwoFactorForm(Form):
         super(TwoFactorForm, self).__init__(*args, **kwargs)
 
     sms_code = sms_code()
-    remember_me = BooleanField("Remember me")
 
     def validate_sms_code(self, field):
         is_valid, reason = self.validate_code_func(field.data)

app/main/views/add_service.py

@@ -12,7 +12,10 @@ from app.main.dao import services_dao, users_dao
 from app.main.forms import AddServiceForm
 from app.notify_client.models import InvitedUser
 
-from app import user_api_client
+from app import (
+    invite_api_client,
+    user_api_client
+)
 
 
 @main.route("/add-service", methods=['GET', 'POST'])
@@ -25,8 +28,8 @@ def add_service():
         # if invited user add to service and redirect to dashboard
         user = users_dao.get_user_by_id(session['user_id'])
         service_id = invited_user['service']
-        user_api_client.add_user_to_service(service_id, user.id, invitation)
+        user_api_client.add_user_to_service(service_id, user.id, invitation.permissions)
-        session.pop('invited_user', None)
+        invite_api_client.accept_invite(service_id, invitation.id)
         return redirect(url_for('main.service_dashboard', service_id=service_id))
 
     form = AddServiceForm(services_dao.find_all_service_names)

app/main/views/dashboard.py

@@ -1,4 +1,10 @@
-from flask import (abort, render_template, session)
+from flask import (
+    abort,
+    render_template,
+    session,
+    flash
+)
+
 from flask_login import login_required
 from app.main import main
 from app.main.dao.services_dao import get_service_by_id
@@ -6,8 +12,6 @@ from app.main.dao import templates_dao
 from notifications_python_client.errors import HTTPError
 from app import job_api_client
 
-from app.utils import user_has_permissions
-
 
 @main.route("/services/<service_id>/dashboard")
 @login_required
@@ -24,6 +28,12 @@ def service_dashboard(service_id):
         service = get_service_by_id(service_id)
         session['service_name'] = service['data']['name']
         session['service_id'] = service['data']['id']
+
+        if session.get('invited_user'):
+            session.pop('invited_user', None)
+            service_name = service['data']['name']
+            message = 'You have sucessfully accepted your invitation and been added to {}'.format(service_name)
+            flash(message, 'default_with_tick')
     except HTTPError as e:
         if e.status_code == 404:
             abort(404)

app/main/views/invites.py

@@ -1,10 +1,15 @@
 from flask import (
     redirect,
     url_for,
-    session
+    session,
+    abort,
+    render_template
 )
 
+from notifications_python_client.errors import HTTPError
+
 from app.main import main
+from app.main.dao.services_dao import get_service_by_id_or_404
 from app import (
     invite_api_client,
     user_api_client
@@ -14,14 +19,30 @@ from app import (
 @main.route("/invitation/<token>")
 def accept_invite(token):
 
-    invited_user = invite_api_client.accept_invite(token)
+    try:
-    existing_user = user_api_client.get_user_by_email(invited_user.email_address)
 
-    if existing_user:
+        invited_user = invite_api_client.check_token(token)
-        user_api_client.add_user_to_service(invited_user.service,
+        if invited_user.status == 'cancelled':
-                                            existing_user.id,
+            from_user = user_api_client.get_user(invited_user.from_user)
-                                            invited_user)
+            service = get_service_by_id_or_404(invited_user.service)
-        return redirect(url_for('main.service_dashboard', service_id=invited_user.service))
+            return render_template('views/cancelled-invitation.html',
-    else:
+                                   from_user=from_user.name,
+                                   service_name=service['name'])
+
+        existing_user = user_api_client.get_user_by_email(invited_user.email_address)
         session['invited_user'] = invited_user.serialize()
-        return redirect(url_for('main.register_from_invite'))
+
+        if existing_user:
+            user_api_client.add_user_to_service(invited_user.service,
+                                                existing_user.id,
+                                                invited_user.permissions)
+            invite_api_client.accept_invite(invited_user.service, invited_user.id)
+            return redirect(url_for('main.service_dashboard', service_id=invited_user.service))
+        else:
+            return redirect(url_for('main.register_from_invite'))
+
+    except HTTPError as e:
+        if e.status_code == 404:
+            abort(404)
+        else:
+            raise e

app/main/views/manage_users.py

@@ -28,11 +28,15 @@ from app.utils import user_has_permissions
 def manage_users(service_id):
     users = user_api_client.get_users_for_service(service_id=service_id)
     invited_users = invite_api_client.get_invites_for_service(service_id=service_id)
+    filtered_invites = []
+    for invite in invited_users:
+        if invite.status != 'accepted':
+            filtered_invites.append(invite)
     return render_template('views/manage-users.html',
                            service_id=service_id,
                            users=users,
                            current_user=current_user,
-                           invited_users=invited_users)
+                           invited_users=filtered_invites)
 
 
 @main.route("/services/<service_id>/users/invite", methods=['GET', 'POST'])

app/main/views/two_factor.py

@@ -1,6 +1,10 @@
 
 from flask import (
-    render_template, redirect, session, url_for)
+    render_template,
+    redirect,
+    session,
+    url_for
+)
 
 from flask_login import login_user
 
@@ -30,7 +34,7 @@ def two_factor():
             if 'password' in session['user_details']:
                 user.set_password(session['user_details']['password'])
                 users_dao.update_user(user)
-            login_user(user, remember=form.remember_me.data if form.remember_me.data else False)
+            login_user(user, remember=True)
         finally:
             del session['user_details']
         if len(services) == 1:

app/notify_client/api_client.py

@@ -68,7 +68,7 @@ class NotificationsAdminAPIClient(NotificationsAPIClient):
             "users": users
         }
         endpoint = "/service/{0}".format(service_id)
-        return self.put(endpoint, data)
+        return self.post(endpoint, data)
 
     def create_service_template(self, name, type_, content, service_id, subject=None):
         """

app/notify_client/invite_api_client.py

@@ -31,7 +31,7 @@ class InviteApiClient(BaseAPIClient):
         invited_users = self._get_invited_users(invites)
         return invited_users
 
-    def accept_invite(self, token):
+    def check_token(self, token):
         resp = self.get(url='/invite/{}'.format(token))
         return InvitedUser(**resp['data'])
 
@@ -40,6 +40,11 @@ class InviteApiClient(BaseAPIClient):
         self.post(url='/service/{0}/invite/{1}'.format(service_id, invited_user_id),
                   data=data)
 
+    def accept_invite(self, service_id, invited_user_id):
+        data = {'status': 'accepted'}
+        self.post(url='/service/{0}/invite/{1}'.format(service_id, invited_user_id),
+                  data=data)
+
     def _get_invited_users(self, invites):
         invited_users = []
         for invite in invites:

app/notify_client/user_api_client.py

@@ -94,9 +94,9 @@ class UserApiClient(BaseAPIClient):
         resp = self.get(endpoint)
         return [User(data) for data in resp['data']]
 
-    def add_user_to_service(self, service_id, user_id, invited_user):
+    def add_user_to_service(self, service_id, user_id, permissions):
         endpoint = '/service/{}/users/{}'.format(service_id, user_id)
-        resp = self.post(endpoint, data=invited_user.serialize(permissions_as_string=True))
+        resp = self.post(endpoint, data={'permissions': permissions})
         return User(resp['data'], max_failed_login_count=self.max_failed_login_count)
 
     def set_user_permissions(self, user_id, service_id, permissions):

app/templates/components/textbox.html

@@ -6,7 +6,8 @@
   help_link=None,
   help_link_text=None,
   width='2-3',
-  suffix=None
+  suffix=None,
+  disabled=False
 ) %}
   <div class="form-group{% if field.errors %} error{% endif %}" {% if autofocus %}data-module="autofocus"{% endif %}>
     <label class="form-label" for="{{ field.name }}">
@@ -22,10 +23,21 @@
         </span>
       {% endif %}
     </label>
-    {{ field(**{
+      {% if disabled %}
-      'class': 'form-control form-control-{} textbox-highlight-textbox'.format(width) if highlight_tags else 'form-control form-control-{} {}'.format(width, 'textbox-right-aligned' if suffix else ''),
+        <p>{{ field(**{
-      'data-module': 'highlight-tags' if highlight_tags else ''
+          'class': 'form-control form-control-{} textbox-highlight-textbox'.format(width) if highlight_tags else 'form-control form-control-{} {}'.format(width, 'textbox-right-aligned' if suffix else ''),
-    }) }}
+          'data-module': 'highlight-tags' if highlight_tags else '',
+          'disabled': 'disabled'
+        }) }}
+      </p>
+      {% else %}
+        {{ field(**{
+          'class': 'form-control form-control-{} textbox-highlight-textbox'.format(width) if highlight_tags else 'form-control form-control-{} {}'.format(width, 'textbox-right-aligned' if suffix else ''),
+          'data-module': 'highlight-tags' if highlight_tags else ''
+        }) }}
+      {% endif %}
+
+
     {% if suffix %}
       <span>{{ suffix }}</span>
     {% endif %}

app/templates/views/cancelled-invitation.html

@@ -0,0 +1,17 @@
+{% extends "withoutnav_template.html" %}
+{% block page_title %}Invitation has been cancelled{% endblock %}
+{% block maincolumn_content %}
+    <div class="grid-row">
+      <div class="column-two-thirds">
+        <h1 class="heading-large">
+          The invitation you were sent has been cancelled
+        </h1>
+        <p>
+          {{ from_user }} decided to cancel this invitation.
+        </p>
+        <p>
+          If you need access to {{ service_name }}, you’ll have to ask them to invite you again.
+        </p>
+      </div>
+    </div>
+{% endblock %}

app/templates/views/register-from-invite.html

@@ -12,12 +12,12 @@ Create an account – GOV.UK Notify
   <div class="column-two-thirds">
     <h1 class="heading-large">Create an account</h1>
     <form method="post" autocomplete="nope">
+      {{ textbox(form.email_address, width='3-4', disabled=True ) }}
       {{ textbox(form.name, width='3-4') }}
       {{ textbox(form.mobile_number, width='3-4') }}
       {{ textbox(form.password, hint="Your password must have at least 10 characters", width='3-4') }}
       {{ page_footer("Continue") }}
       {{form.service}}
-      {{form.email_address}}
     </form>
   </div>
 </div>

app/templates/views/service_dashboard.html

@@ -56,7 +56,7 @@
         jobs,
         caption="Recent text messages",
         empty_message='You haven’t sent any text messages yet',
-        field_headings=['Job', 'Created', right_aligned_field_heading('Status')]
+        field_headings=['Job', 'Created', right_aligned_field_heading('completion')]
       ) %}
         {% call field() %}
           <a href="{{ url_for('.view_job', service_id=service_id, job_id=item.id) }}">{{ item.original_file_name }}</a>
@@ -65,7 +65,7 @@
           {{ item.created_at|format_datetime }}
         {% endcall %}
         {% call field(align='right') %}
-          {{ item.status }}
+          {{ (item.notifications_sent / item.notification_count * 100)|round|int }}%
         {% endcall %}
       {% endcall %}
       {% if more_jobs_to_show %}

app/templates/views/two-factor.html

@@ -23,7 +23,6 @@
         help_link=url_for('.verification_code_not_received'),
         help_link_text='I haven’t received a text message'
       ) }}
-      {{ checkbox(form.remember_me) }}
       {{ page_footer(
         "Continue"
       ) }}

tests/__init__.py

@@ -48,12 +48,12 @@ def api_key_json(id_, name, expiry_date=None):
             }
 
 
-def invite_json(id, from_user, service_id, email_address, permissions, created_at):
+def invite_json(id, from_user, service_id, email_address, permissions, created_at, status):
     return {'id': id,
             'from_user': from_user,
             'service': service_id,
             'email_address': email_address,
-            'status': 'pending',
+            'status': status,
             'permissions': permissions,
             'created_at': created_at
             }
@@ -110,6 +110,7 @@ def job_json():
         'file_name': '{}.csv'.format(job_id),
         'created_at': created_at,
         'notification_count': 1,
+        'notifications_sent': 1,
         'status': ''
         }
     return data

tests/app/main/notify_client/test_invite_client.py

@@ -0,0 +1,20 @@
+from app.notify_client.invite_api_client import InviteApiClient
+
+
+def test_client_returns_invite(mocker, sample_invite):
+
+    sample_invite['status'] = 'pending'
+    service_id = sample_invite['service']
+
+    expected_data = {'data': [sample_invite]}
+
+    expected_url = '/service/{}/invite'.format(service_id)
+
+    client = InviteApiClient()
+    mock_get = mocker.patch('app.notify_client.invite_api_client.InviteApiClient.get', return_value=expected_data)
+
+    invites = client.get_invites_for_service(service_id)
+
+    mock_get.assert_called_once_with(expected_url)
+    assert len(invites) == 1
+    assert invites[0].status == 'pending'

tests/app/main/views/test_accept_invite.py

@@ -2,27 +2,33 @@ from flask import url_for
 
 from bs4 import BeautifulSoup
 
+import app
+from tests.conftest import sample_invite as create_sample_invite
+from tests.conftest import mock_check_invite_token as mock_check_token_invite
+
 
 def test_existing_user_accept_invite_calls_api_and_redirects_to_dashboard(app_,
                                                                           service_one,
                                                                           api_user_active,
                                                                           sample_invite,
-                                                                          sample_invited_user,
+                                                                          mock_check_invite_token,
-                                                                          mock_accept_invite,
                                                                           mock_get_user_by_email,
-                                                                          mock_add_user_to_service):
+                                                                          mock_add_user_to_service,
+                                                                          mock_accept_invite):
 
     expected_service = service_one['id']
     expected_redirect_location = 'http://localhost/services/{}/dashboard'.format(expected_service)
+    expected_permissions = ['send_messages', 'manage_service', 'manage_api_keys']
 
     with app_.test_request_context():
         with app_.test_client() as client:
 
             response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
 
-            mock_accept_invite.assert_called_with('thisisnotarealtoken')
+            mock_check_invite_token.assert_called_with('thisisnotarealtoken')
             mock_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
-            mock_add_user_to_service.assert_called_with(expected_service, api_user_active.id, sample_invited_user)
+            mock_add_user_to_service.assert_called_with(expected_service, api_user_active.id, expected_permissions)
+            mock_accept_invite.assert_called_with(expected_service, sample_invite['id'])
 
             assert response.status_code == 302
             assert response.location == expected_redirect_location
@@ -32,21 +38,22 @@ def test_existing_signed_out_user_accept_invite_redirects_to_sign_in(app_,
                                                                      service_one,
                                                                      api_user_active,
                                                                      sample_invite,
-                                                                     sample_invited_user,
+                                                                     mock_check_invite_token,
-                                                                     mock_accept_invite,
                                                                      mock_get_user_by_email,
-                                                                     mock_add_user_to_service):
+                                                                     mock_add_user_to_service,
+                                                                     mock_accept_invite):
 
     expected_service = service_one['id']
-
+    expected_permissions = ['send_messages', 'manage_service', 'manage_api_keys']
     with app_.test_request_context():
         with app_.test_client() as client:
 
             response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
 
-            mock_accept_invite.assert_called_with('thisisnotarealtoken')
+            mock_check_invite_token.assert_called_with('thisisnotarealtoken')
             mock_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
-            mock_add_user_to_service.assert_called_with(expected_service, api_user_active.id, sample_invited_user)
+            mock_add_user_to_service.assert_called_with(expected_service, api_user_active.id, expected_permissions)
+            mock_accept_invite.assert_called_with(expected_service, sample_invite['id'])
 
             assert response.status_code == 200
             page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
@@ -55,10 +62,10 @@ def test_existing_signed_out_user_accept_invite_redirects_to_sign_in(app_,
 
 def test_new_user_accept_invite_calls_api_and_redirects_to_registration(app_,
                                                                         service_one,
-                                                                        sample_invite,
+                                                                        mock_check_invite_token,
-                                                                        mock_accept_invite,
                                                                         mock_dont_get_user_by_email,
-                                                                        mock_add_user_to_service):
+                                                                        mock_add_user_to_service,
+                                                                        mock_accept_invite):
 
     expected_redirect_location = 'http://localhost/register-from-invite'
 
@@ -67,21 +74,73 @@ def test_new_user_accept_invite_calls_api_and_redirects_to_registration(app_,
 
             response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
 
-            mock_accept_invite.assert_called_with('thisisnotarealtoken')
+            mock_check_invite_token.assert_called_with('thisisnotarealtoken')
             mock_dont_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
 
             assert response.status_code == 302
             assert response.location == expected_redirect_location
 
 
+def test_new_user_accept_invite_calls_api_and_views_registration_page(app_,
+                                                                      service_one,
+                                                                      mock_check_invite_token,
+                                                                      mock_dont_get_user_by_email,
+                                                                      mock_add_user_to_service,
+                                                                      mock_accept_invite):
+
+    with app_.test_request_context():
+        with app_.test_client() as client:
+
+            response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
+
+            mock_check_invite_token.assert_called_with('thisisnotarealtoken')
+            mock_dont_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
+
+            assert response.status_code == 200
+            page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
+            assert page.h1.string.strip() == 'Create an account'
+
+            form = page.find('form')
+            email = form.find('input', id='email_address')
+            name = form.find('input', id='name')
+            password = form.find('input', id='password')
+            service = form.find('input', type='hidden', id='service')
+
+            assert email
+            assert email.attrs['disabled']
+            assert name
+            assert password
+            assert service
+            assert service.attrs['value'] == service_one['id']
+
+
+def test_cancelled_invited_user_accepts_invited_redirect_to_cancelled_invitation(app_,
+                                                                                 service_one,
+                                                                                 mocker,
+                                                                                 mock_get_user,
+                                                                                 mock_get_service
+                                                                                 ):
+    with app_.test_request_context():
+        with app_.test_client() as client:
+            cancelled_invitation = create_sample_invite(mocker, service_one, status='cancelled')
+            mock_check_token_invite(mocker, cancelled_invitation)
+            response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
+
+            app.invite_api_client.check_token.assert_called_with('thisisnotarealtoken')
+            assert response.status_code == 200
+            page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
+            assert page.h1.string.strip() == 'The invitation you were sent has been cancelled'
+
+
 def test_new_user_accept_invite_completes_new_registration_redirects_to_verify(app_,
                                                                                service_one,
                                                                                sample_invite,
-                                                                               mock_accept_invite,
+                                                                               mock_check_invite_token,
                                                                                mock_dont_get_user_by_email,
                                                                                mock_register_user,
                                                                                mock_send_verify_code,
-                                                                               mock_add_user_to_service):
+                                                                               mock_add_user_to_service,
+                                                                               mock_accept_invite):
 
     expected_service = service_one['id']
     expected_email = sample_invite['email_address']
@@ -122,8 +181,7 @@ def test_new_user_accept_invite_completes_new_registration_redirects_to_verify(a
 def test_new_invited_user_verifies_and_added_to_service(app_,
                                                         service_one,
                                                         sample_invite,
-                                                        sample_invited_user,
+                                                        mock_check_invite_token,
-                                                        mock_accept_invite,
                                                         mock_dont_get_user_by_email,
                                                         mock_register_user,
                                                         mock_send_verify_code,
@@ -131,6 +189,7 @@ def test_new_invited_user_verifies_and_added_to_service(app_,
                                                         mock_get_user,
                                                         mock_update_user,
                                                         mock_add_user_to_service,
+                                                        mock_accept_invite,
                                                         mock_get_service,
                                                         mock_get_service_templates,
                                                         mock_get_jobs):
@@ -156,12 +215,18 @@ def test_new_invited_user_verifies_and_added_to_service(app_,
 
             # when they post codes back to admin user should be added to
             # service and sent on to dash board
+            expected_permissions = ['send_messages', 'manage_service', 'manage_api_keys']
             with client.session_transaction() as session:
                 new_user_id = session['user_id']
-                mock_add_user_to_service.assert_called_with(data['service'], new_user_id, sample_invited_user)
+                mock_add_user_to_service.assert_called_with(data['service'], new_user_id, expected_permissions)
+
+            mock_accept_invite.assert_called_with(data['service'], sample_invite['id'])
 
             page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
             element = page.find('h2', class_='navigation-service-name').find('a')
             assert element.text == 'Test Service'
             service_link = element.attrs['href']
             assert service_link == '/services/{}/dashboard'.format(service_one['id'])
+
+            flash_banner = page.find('div', class_='banner-default-with-tick').string.strip()
+            assert flash_banner == 'You have sucessfully accepted your invitation and been added to Test Service'

tests/app/main/views/test_manage_users.py

@@ -2,6 +2,8 @@ from flask import url_for
 
 from bs4 import BeautifulSoup
 
+from app.notify_client.models import InvitedUser
+
 
 def test_should_show_overview_page(
     app_,
@@ -180,3 +182,65 @@ def test_cancel_invited_user_cancels_user_invitations(app_,
 
             assert response.status_code == 302
             assert response.location == url_for('main.manage_users', service_id=service_id, _external=True)
+
+
+def test_manage_users_shows_invited_user(app_,
+                                         mocker,
+                                         api_user_active,
+                                         mock_get_service,
+                                         mock_login,
+                                         mock_has_permissions,
+                                         mock_get_users_by_service,
+                                         sample_invite):
+
+    import uuid
+    invited_user_id = uuid.uuid4()
+    sample_invite['id'] = invited_user_id
+    data = [InvitedUser(**sample_invite)]
+
+    with app_.test_request_context():
+        with app_.test_client() as client:
+            client.login(api_user_active)
+
+            mocker.patch('app.invite_api_client.get_invites_for_service', return_value=data)
+
+            response = client.get(url_for('main.manage_users', service_id=55555))
+
+            assert response.status_code == 200
+            page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
+            assert page.h1.string.strip() == 'Manage team'
+            invites_table = page.find_all('table')[1]
+            cols = invites_table.find_all('td')
+            assert cols[0].text.strip() == 'invited_user@test.gov.uk'
+            assert cols[4].text.strip() == 'Cancel invitation'
+
+
+def test_manage_users_does_not_show_accepted_invite(app_,
+                                                    mocker,
+                                                    api_user_active,
+                                                    mock_get_service,
+                                                    mock_login,
+                                                    mock_has_permissions,
+                                                    mock_get_users_by_service,
+                                                    sample_invite):
+
+    import uuid
+    invited_user_id = uuid.uuid4()
+    sample_invite['id'] = invited_user_id
+    sample_invite['status'] = 'accepted'
+    data = [InvitedUser(**sample_invite)]
+
+    with app_.test_request_context():
+        with app_.test_client() as client:
+            client.login(api_user_active)
+
+            mocker.patch('app.invite_api_client.get_invites_for_service', return_value=data)
+
+            response = client.get(url_for('main.manage_users', service_id=55555))
+
+            assert response.status_code == 200
+            page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
+            assert page.h1.string.strip() == 'Manage team'
+            tables = page.find_all('table')
+            assert len(tables) == 1
+            assert not page.find(text='invited_user@test.gov.uk')

tests/conftest.py

@@ -602,7 +602,7 @@ def mock_s3_upload(mocker):
 
 
 @pytest.fixture(scope='function')
-def sample_invite(mocker, service_one):
+def sample_invite(mocker, service_one, status='pending'):
     import datetime
     id = str(uuid.uuid4())
     from_user = service_one['users'][0]
@@ -610,7 +610,7 @@ def sample_invite(mocker, service_one):
     service_id = service_one['id']
     permissions = 'send_messages,manage_service,manage_api_keys'
     created_at = str(datetime.datetime.now())
-    return invite_json(id, from_user, service_id, email_address, permissions, created_at)
+    return invite_json(id, from_user, service_id, email_address, permissions, created_at, status)
 
 
 @pytest.fixture(scope='function')
@@ -646,15 +646,22 @@ def mock_get_invites_for_service(mocker, service_one, sample_invite):
 
 
 @pytest.fixture(scope='function')
-def mock_accept_invite(mocker, sample_invite):
+def mock_check_invite_token(mocker, sample_invite):
-    def _accept_token(token):
+    def _check_token(token):
         return InvitedUser(**sample_invite)
-    return mocker.patch('app.invite_api_client.accept_invite', side_effect=_accept_token)
+    return mocker.patch('app.invite_api_client.check_token', side_effect=_check_token)
+
+
+@pytest.fixture(scope='function')
+def mock_accept_invite(mocker, sample_invite):
+    def _accept(service_id, invite_id):
+        return InvitedUser(**sample_invite)
+    return mocker.patch('app.invite_api_client.accept_invite', side_effect=_accept)
 
 
 @pytest.fixture(scope='function')
 def mock_add_user_to_service(mocker, service_one, api_user_active):
-    def _add_user(service_id, user_id, invited_user):
+    def _add_user(service_id, user_id, permissions):
         return api_user_active
     return mocker.patch('app.user_api_client.add_user_to_service', side_effect=_add_user)