darkhelm/notifications-admin
1
0
Fork 0
mirror of https://github.com/GSA/notifications-admin.git synced 2026-08-19 14:09:20 -04:00
Code Issues Packages Projects Releases Wiki Activity

Working tests, hopefully all code changes done.

Browse Source
This commit is contained in:
Nicholas Staples
2016-01-27 12:22:32 +00:00
parent ce81a6f540
commit 6959d695d3
57 changed files with 1143 additions and 1578 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
tests/app/main/dao/test_roles_dao.py
View File

@@ -1,26 +0,0 @@
import pytest
import sqlalchemy
from app.models import Roles
from app.main.dao import roles_dao
def test_insert_role_should_be_able_to_get_role(app_, db_, db_session):
role = Roles(id=1000, role='some role for test')
roles_dao.insert_role(role)
saved_role = roles_dao.get_role_by_id(role.id)
assert saved_role == role
def test_insert_role_will_throw_error_if_role_already_exists(app_,
db_,
db_session):
role1 = roles_dao.get_role_by_id(1)
assert role1.id == 1
role = Roles(id=1, role='cannot create a duplicate')
with pytest.raises(sqlalchemy.orm.exc.FlushError) as error:
roles_dao.insert_role(role)
assert 'conflicts with persistent instance' in str(error.value)

22
tests/app/main/dao/test_service_dao.py
View File

@@ -3,20 +3,16 @@ import sqlalchemy
from app.main.dao import services_dao
def test_can_insert_new_service(db_,
db_session,
mock_api_user,
def test_can_insert_new_service(api_user_active,
mock_create_service,
mock_user_dao_get_by_email):
service_name = 'testing service'
id_ = services_dao.insert_new_service(service_name, mock_api_user.id)
id_ = services_dao.insert_new_service(service_name, api_user_active.id)
mock_create_service.assert_called_once_with(
service_name, False, 1000, True, mock_api_user.id)
service_name, False, 1000, True, api_user_active.id)
def test_unrestrict_service_updates_the_service(db_,
db_session,
mock_get_service,
def test_unrestrict_service_updates_the_service(mock_get_service,
mock_update_service,
mock_user_dao_get_by_email):
service_one = mock_get_service.side_effect(123)['data']
@@ -29,9 +25,7 @@ def test_unrestrict_service_updates_the_service(db_,
service_one['users'])
def test_activate_service_update_service(db_,
db_session,
mock_api_user,
def test_activate_service_update_service(api_user_active,
mock_get_service,
mock_update_service,
mock_user_dao_get_by_email):
@@ -45,20 +39,20 @@ def test_activate_service_update_service(db_,
service_one['users'])
def test_get_service_returns_none_if_service_does_not_exist(db_, db_session, mock_get_service):
def test_get_service_returns_none_if_service_does_not_exist(mock_get_service):
mock_get_service.side_effect = lambda x: None
service = services_dao.get_service_by_id(1)
assert service is None
def test_find_by_service_name_returns_right_service(db_, db_session, mock_get_services):
def test_find_by_service_name_returns_right_service(mock_get_services):
service_name = "service_one"
service = services_dao.find_service_by_service_name(service_name)
assert mock_get_services.called
assert service['name'] == service_name
def test_should_return_list_of_service_names(db_, db_session, mock_get_services):
def test_should_return_list_of_service_names(mock_get_services):
expected = ['service_one', 'service_two']
actual = services_dao.find_all_service_names()
assert mock_get_services.called

195
tests/app/main/dao/test_users_dao.py
View File

@@ -2,17 +2,18 @@ from datetime import datetime
import pytest
import sqlalchemy
from app.main.encryption import check_hash
from app.models import User
from app.main.dao import users_dao
@pytest.mark.xfail(reason='Tests will be moved to api')
def test_insert_user_should_add_user(db_, db_session):
user = User(name='test insert',
password='somepassword',
email_address='test@insert.gov.uk',
mobile_number='+441234123412',
role_id=1)
def test_insert_user_should_add_user():
# user = User(name='test insert',
# password='somepassword',
# email_address='test@insert.gov.uk',
# mobile_number='+441234123412',
# role_id=1)
user = None
users_dao.insert_user(user)
saved_user = users_dao.get_user_by_id(user.id)
@@ -20,24 +21,28 @@ def test_insert_user_should_add_user(db_, db_session):
@pytest.mark.xfail(reason='Tests will be moved to api')
def test_insert_user_with_role_that_does_not_exist_fails(db_, db_session):
user = User(name='role does not exist',
password='somepassword',
email_address='test@insert.gov.uk',
mobile_number='+441234123412',
role_id=100)
def test_insert_user_with_role_that_does_not_exist_fails():
# user = User(name='role does not exist',
# password='somepassword',
# email_address='test@insert.gov.uk',
# mobile_number='+441234123412',
# role_id=100)
user = None
with pytest.raises(sqlalchemy.exc.IntegrityError) as error:
users_dao.insert_user(user)
assert 'insert or update on table "users" violates foreign key constraint "users_role_id_fkey"' in str(error.value)
@pytest.mark.xfail(reason='Not implemented yet on api client')
def test_get_user_by_email(db_, db_session):
user = User(name='test_get_by_email',
password='somepassword',
email_address='email@example.gov.uk',
mobile_number='+441234153412',
role_id=1)
def test_get_user_by_email():
# user = User(name='test_get_by_email',
# password='somepassword',
# email_address='email@example.gov.uk',
# mobile_number='+441234153412',
# role_id=1)
user = None
users_dao.insert_user(user)
retrieved = users_dao.get_user_by_email(user.email_address)
@@ -45,22 +50,26 @@ def test_get_user_by_email(db_, db_session):
@pytest.mark.xfail(reason='Not implemented yet on api client')
def test_get_all_users_returns_all_users(db_, db_session):
user1 = User(name='test one',
password='somepassword',
email_address='test1@get_all.gov.uk',
mobile_number='+441234123412',
role_id=1)
user2 = User(name='test two',
password='some2ndpassword',
email_address='test2@get_all.gov.uk',
mobile_number='+441234123412',
role_id=1)
user3 = User(name='test three',
password='some2ndpassword',
email_address='test3@get_all.gov.uk',
mobile_number='+441234123412',
role_id=1)
def test_get_all_users_returns_all_users():
# user1 = User(name='test one',
# password='somepassword',
# email_address='test1@get_all.gov.uk',
# mobile_number='+441234123412',
# role_id=1)
# user2 = User(name='test two',
# password='some2ndpassword',
# email_address='test2@get_all.gov.uk',
# mobile_number='+441234123412',
# role_id=1)
# user3 = User(name='test three',
# password='some2ndpassword',
# email_address='test3@get_all.gov.uk',
# mobile_number='+441234123412',
# role_id=1)
user1 = None
user2 = None
user3 = None
users_dao.insert_user(user1)
users_dao.insert_user(user2)
@@ -71,12 +80,13 @@ def test_get_all_users_returns_all_users(db_, db_session):
@pytest.mark.xfail(reason='Not implemented yet on api client')
def test_increment_failed_lockout_count_should_increade_count_by_1(db_, db_session):
user = User(name='cannot remember password',
password='somepassword',
email_address='test1@get_all.gov.uk',
mobile_number='+441234123412',
role_id=1)
def test_increment_failed_lockout_count_should_increade_count_by_1():
# user = User(name='cannot remember password',
# password='somepassword',
# email_address='test1@get_all.gov.uk',
# mobile_number='+441234123412',
# role_id=1)
user = None
users_dao.insert_user(user)
savedUser = users_dao.get_user_by_id(user.id)
@@ -86,12 +96,13 @@ def test_increment_failed_lockout_count_should_increade_count_by_1(db_, db_sessi
@pytest.mark.xfail(reason='Not implemented yet on api client')
def test_user_is_locked_if_failed_login_count_is_10_or_greater(db_, db_session):
user = User(name='cannot remember password',
password='somepassword',
email_address='test1@get_all.gov.uk',
mobile_number='+441234123412',
role_id=1)
def test_user_is_locked_if_failed_login_count_is_10_or_greater():
# user = User(name='cannot remember password',
# password='somepassword',
# email_address='test1@get_all.gov.uk',
# mobile_number='+441234123412',
# role_id=1)
user = None
users_dao.insert_user(user)
saved_user = users_dao.get_user_by_id(user.id)
assert saved_user.is_locked() is False
@@ -105,13 +116,14 @@ def test_user_is_locked_if_failed_login_count_is_10_or_greater(db_, db_session):
@pytest.mark.xfail(reason='Not implemented yet on api client')
def test_user_is_active_is_false_if_state_is_inactive(db_, db_session):
user = User(name='inactive user',
password='somepassword',
email_address='test1@get_all.gov.uk',
mobile_number='+441234123412',
role_id=1,
state='inactive')
def test_user_is_active_is_false_if_state_is_inactive():
# user = User(name='inactive user',
# password='somepassword',
# email_address='test1@get_all.gov.uk',
# mobile_number='+441234123412',
# role_id=1,
# state='inactive')
user = None
users_dao.insert_user(user)
saved_user = users_dao.get_user_by_id(user.id)
@@ -132,20 +144,21 @@ def test_should_update_user_to_active(mock_activate_user):
@pytest.mark.xfail(reason='Not implemented yet on api client')
def test_should_throws_error_when_id_does_not_exist(db_, db_session):
def test_should_throws_error_when_id_does_not_exist():
with pytest.raises(AttributeError) as error:
users_dao.activate_user(123)
assert '''object has no attribute 'state''''' in str(error.value)
@pytest.mark.xfail(reason='Not implemented yet on api client')
def test_should_update_email_address(db_, db_session):
user = User(name='Update Email',
password='somepassword',
email_address='test@it.gov.uk',
mobile_number='+441234123412',
role_id=1,
state='inactive')
def test_should_update_email_address():
# user = User(name='Update Email',
# password='somepassword',
# email_address='test@it.gov.uk',
# mobile_number='+441234123412',
# role_id=1,
# state='inactive')
user = None
users_dao.insert_user(user)
saved = users_dao.get_user_by_id(user.id)
@@ -156,13 +169,14 @@ def test_should_update_email_address(db_, db_session):
@pytest.mark.xfail(reason='Not implemented yet on api client')
def test_should_update_password(db_, db_session):
user = User(name='Update Email',
password='somepassword',
email_address='test@it.gov.uk',
mobile_number='+441234123412',
role_id=1,
state='active')
def test_should_update_password():
# user = User(name='Update Email',
# password='somepassword',
# email_address='test@it.gov.uk',
# mobile_number='+441234123412',
# role_id=1,
# state='active')
user = None
start = datetime.now()
users_dao.insert_user(user)
@@ -177,19 +191,21 @@ def test_should_update_password(db_, db_session):
@pytest.mark.xfail(reason='Not implemented yet on api client')
def test_should_return_list_of_all_email_addresses(db_, db_session):
first = User(name='First Person',
password='somepassword',
email_address='first@it.gov.uk',
mobile_number='+441234123412',
role_id=1,
state='active')
second = User(name='Second Person',
password='somepassword',
email_address='second@it.gov.uk',
mobile_number='+441234123412',
role_id=1,
state='active')
def test_should_return_list_of_all_email_addresses():
# first = User(name='First Person',
# password='somepassword',
# email_address='first@it.gov.uk',
# mobile_number='+441234123412',
# role_id=1,
# state='active')
first = None
# second = User(name='Second Person',
# password='somepassword',
# email_address='second@it.gov.uk',
# mobile_number='+441234123412',
# role_id=1,
# state='active')
second = None
users_dao.insert_user(first)
users_dao.insert_user(second)
@@ -199,13 +215,14 @@ def test_should_return_list_of_all_email_addresses(db_, db_session):
@pytest.mark.xfail(reason='Not implemented yet on api client')
def test_should_update_state_to_request_password_reset(db_, db_session):
user = User(name='Requesting Password Resest',
password='somepassword',
email_address='request@new_password.gov.uk',
mobile_number='+441234123412',
role_id=1,
state='active')
def test_should_update_state_to_request_password_reset():
# user = User(name='Requesting Password Resest',
# password='somepassword',
# email_address='request@new_password.gov.uk',
# mobile_number='+441234123412',
# role_id=1,
# state='active')
user = None
users_dao.insert_user(user)
users_dao.request_password_reset(user.email_address)
saved = users_dao.get_user_by_email(user.email_address)

37
tests/app/main/dao/test_verify_codes_dao.py
View File

@@ -1,37 +0,0 @@
import sqlalchemy
from pytest import fail
from app.main.dao import verify_codes_dao
from app.main.encryption import check_hash
def test_insert_new_code_and_get_it_back(app_, db_, db_session):
verify_codes_dao.add_code(user_id=1, code='12345', code_type='email')
saved_codes = verify_codes_dao.get_codes(user_id=1, code_type='email')
assert len(saved_codes) == 1
saved_code = saved_codes[0]
assert saved_code.user_id == 1
assert check_hash('12345', saved_code.code)
assert saved_code.code_type == 'email'
assert saved_code.code_used is False
def test_insert_new_code_should_thrw_exception_when_type_does_not_exist(app_,
db_,
db_session):
try:
verify_codes_dao.add_code(user_id=1, code='23545', code_type='not_real')
fail('Should have thrown an exception')
except sqlalchemy.exc.DataError as e:
assert 'invalid input value for enum verify_code_types: "not_real"' in e.orig.pgerror
def test_should_return_none_if_code_is_used(app_,
db_,
db_session):
code = verify_codes_dao.add_code(user_id=1, code='12345', code_type='email')
verify_codes_dao.use_code(code.id)
saved_code = verify_codes_dao.get_code_by_code(user_id=1, code_type='email', code='12345')
assert not saved_code

12
tests/app/main/notify_client/test_sender.py
View File

@@ -4,17 +4,13 @@ from pytest import fail
from app.notify_client.sender import generate_token, check_token
def test_should_return_email_from_signed_token(app_,
db_,
db_session):
def test_should_return_email_from_signed_token(app_):
email = 'email@something.com'
token = generate_token(email)
assert email == check_token(token)
def test_should_throw_exception_when_token_is_tampered_with(app_,
db_,
db_session):
def test_should_throw_exception_when_token_is_tampered_with(app_):
email = 'email@something.com'
token = generate_token(email)
try:
@@ -24,9 +20,7 @@ def test_should_throw_exception_when_token_is_tampered_with(app_,
pass
def test_return_none_when_token_is_expired(app_,
db_,
db_session):
def test_return_none_when_token_is_expired(app_):
with app_.test_request_context():
app_.config['TOKEN_MAX_AGE_SECONDS'] = -1000
email = 'email@something.com'

4
tests/app/main/test_add_service_form.py
View File

@@ -2,9 +2,7 @@ from app.main.forms import AddServiceForm
from werkzeug.datastructures import MultiDict
def test_form_should_have_errors_when_duplicate_service_is_added(app_,
db_,
db_session):
def test_form_should_have_errors_when_duplicate_service_is_added(app_):
def _get_form_names():
return ['some service', 'more names']
with app_.test_request_context():

4
tests/app/main/test_create_api_key_form.py
View File

@@ -3,9 +3,7 @@ from werkzeug.datastructures import MultiDict
from app.main.forms import CreateKeyForm
def test_return_validation_error_when_key_name_exists(app_,
db_,
db_session):
def test_return_validation_error_when_key_name_exists(app_):
def _get_names():
return ['some key', 'another key']

53
tests/app/main/test_two_factor_form.py
View File

@@ -1,70 +1,61 @@
from datetime import datetime, timedelta
from app.main.dao import verify_codes_dao
from app.main.forms import TwoFactorForm
from app.main.dao import users_dao
from tests import create_test_user
def test_form_is_valid_returns_no_errors(app_, db_, db_session):
def test_form_is_valid_returns_no_errors(app_, mock_check_verify_code):
with app_.test_request_context(method='POST',
data={'sms_code': '12345'}) as req:
user = set_up_test_data()
codes = verify_codes_dao.get_codes(user.id)
form = TwoFactorForm(codes)
def _check_code(code):
return users_dao.check_verify_code('1', code, "sms")
form = TwoFactorForm(_check_code)
assert form.validate() is True
assert len(form.errors) == 0
def test_returns_errors_when_code_is_too_short(app_, db_, db_session):
def test_returns_errors_when_code_is_too_short(app_, mock_check_verify_code):
with app_.test_request_context(method='POST',
data={'sms_code': '145'}) as req:
user = set_up_test_data()
codes = verify_codes_dao.get_codes(user.id)
form = TwoFactorForm(codes)
def _check_code(code):
return users_dao.check_verify_code('1', code, "sms")
form = TwoFactorForm(_check_code)
assert form.validate() is False
assert len(form.errors) == 1
assert set(form.errors) == set({'sms_code': ['Code must be 5 digits', 'Code does not match']})
def test_returns_errors_when_code_is_missing(app_, db_, db_session):
def test_returns_errors_when_code_is_missing(app_, mock_check_verify_code):
with app_.test_request_context(method='POST',
data={}) as req:
user = set_up_test_data()
codes = verify_codes_dao.get_codes(user.id)
form = TwoFactorForm(codes)
def _check_code(code):
return users_dao.check_verify_code('1', code, "sms")
form = TwoFactorForm(_check_code)
assert form.validate() is False
assert len(form.errors) == 1
assert set(form.errors) == set({'sms_code': ['Code must not be empty']})
def test_returns_errors_when_code_contains_letters(app_, db_, db_session):
def test_returns_errors_when_code_contains_letters(app_, mock_check_verify_code):
with app_.test_request_context(method='POST',
data={'sms_code': 'asdfg'}) as req:
user = set_up_test_data()
codes = verify_codes_dao.get_codes(user.id)
form = TwoFactorForm(codes)
def _check_code(code):
return users_dao.check_verify_code('1', code, "sms")
form = TwoFactorForm(_check_code)
assert form.validate() is False
assert len(form.errors) == 1
assert set(form.errors) == set({'sms_code': ['Code must be 5 digits', 'Code does not match']})
def test_should_return_errors_when_code_is_expired(app_, db_, db_session):
def test_should_return_errors_when_code_is_expired(app_,
mock_check_verify_code_code_expired):
with app_.test_request_context(method='POST',
data={'sms_code': '23456'}) as req:
user = create_test_user('active')
verify_codes_dao.add_code_with_expiry(user_id=user.id,
code='23456',
code_type='sms',
expiry=datetime.now() + timedelta(hours=-2))
codes = verify_codes_dao.get_codes(user.id)
form = TwoFactorForm(codes)
def _check_code(code):
return users_dao.check_verify_code('1', code, "sms")
form = TwoFactorForm(_check_code)
assert form.validate() is False
errors = form.errors
assert len(errors) == 1
assert errors == {'sms_code': ['Code has expired']}
def set_up_test_data():
user = create_test_user('active')
verify_codes_dao.add_code(user_id=user.id, code='12345', code_type='sms')
return user

91
tests/app/main/test_verify_form.py
View File

@@ -1,15 +1,18 @@
from datetime import datetime, timedelta
from app.main.dao import verify_codes_dao
from app.main.forms import VerifyForm
from app.main.dao import users_dao
from tests import create_test_user
def test_form_should_have_error_when_code_is_not_valid(app_, db_, db_session):
def test_form_should_have_error_when_code_is_not_valid(app_,
mock_check_verify_code):
with app_.test_request_context(method='POST',
data={'sms_code': '12345aa', 'email_code': 'abcde'}) as req:
user = set_up_test_data()
codes = verify_codes_dao.get_codes(user.id)
form = VerifyForm(codes)
def _check_code(code, code_type):
return users_dao.check_verify_code('1', code, code_type)
form = VerifyForm(_check_code)
assert form.validate() is False
errors = form.errors
assert len(errors) == 2
@@ -19,12 +22,15 @@ def test_form_should_have_error_when_code_is_not_valid(app_, db_, db_session):
assert set(errors) == set(expected)
def test_should_return_errors_when_code_missing(app_, db_, db_session):
def test_should_return_errors_when_code_missing(app_,
mock_check_verify_code):
with app_.test_request_context(method='POST',
data={}) as req:
user = set_up_test_data()
codes = verify_codes_dao.get_codes(user.id)
form = VerifyForm(codes)
def _check_code(code, code_type):
return users_dao.check_verify_code('1', code, code_type)
form = VerifyForm(_check_code)
assert form.validate() is False
errors = form.errors
expected = {'sms_code': ['SMS code can not be empty'],
@@ -33,12 +39,15 @@ def test_should_return_errors_when_code_missing(app_, db_, db_session):
assert set(errors) == set(expected)
def test_should_return_errors_when_code_is_too_short(app_, db_, db_session):
def test_should_return_errors_when_code_is_too_short(app_,
mock_check_verify_code):
with app_.test_request_context(method='POST',
data={'sms_code': '123', 'email_code': '123'}) as req:
user = set_up_test_data()
codes = verify_codes_dao.get_codes(user.id)
form = VerifyForm(codes)
def _check_code(code, code_type):
return users_dao.check_verify_code('1', code, code_type)
form = VerifyForm(_check_code)
assert form.validate() is False
errors = form.errors
expected = {'sms_code': ['Code must be 5 digits', 'Code does not match'],
@@ -47,62 +56,36 @@ def test_should_return_errors_when_code_is_too_short(app_, db_, db_session):
assert set(errors) == set(expected)
def test_should_return_errors_when_code_does_not_match(app_, db_, db_session):
def test_should_return_errors_when_code_does_not_match(app_,
mock_check_verify_code_code_not_found):
with app_.test_request_context(method='POST',
data={'sms_code': '34567', 'email_code': '34567'}) as req:
user = set_up_test_data()
codes = verify_codes_dao.get_codes(user.id)
form = VerifyForm(codes)
def _check_code(code, code_type):
return users_dao.check_verify_code('1', code, code_type)
form = VerifyForm(_check_code)
assert form.validate() is False
errors = form.errors
expected = {'sms_code': ['Code does not match'],
'email_code': ['Code does not match']}
expected = {'sms_code': ['Code not found'],
'email_code': ['Code not found']}
assert len(errors) == 2
assert set(errors) == set(expected)
def test_should_return_errors_when_code_is_expired(app_, db_, db_session):
def test_should_return_errors_when_code_is_expired(app_,
mock_check_verify_code_code_expired):
with app_.test_request_context(method='POST',
data={'sms_code': '23456',
'email_code': '23456'}) as req:
user = create_test_user('pending')
verify_codes_dao.add_code_with_expiry(user_id=user.id,
code='23456',
code_type='sms',
expiry=datetime.now() + timedelta(hours=-2))
verify_codes_dao.add_code_with_expiry(user_id=user.id,
code='23456',
code_type='email',
expiry=datetime.now() + timedelta(hours=-2))
codes = verify_codes_dao.get_codes(user.id)
form = VerifyForm(codes)
def _check_code(code, code_type):
return users_dao.check_verify_code('1', code, code_type)
form = VerifyForm(_check_code)
assert form.validate() is False
errors = form.errors
expected = {'sms_code': ['Code has expired'],
'email_code': ['Code has expired']}
assert len(errors) == 2
assert set(errors) == set(expected)
def test_should_return_valid_form_when_many_codes_exist(app_,
db_,
db_session):
with app_.test_request_context(method='POST',
data={'sms_code': '23456',
'email_code': '23456'}) as req:
user = set_up_test_data()
verify_codes_dao.add_code(user_id=user.id, code='23456', code_type='email')
verify_codes_dao.add_code(user_id=user.id, code='23456', code_type='sms')
verify_codes_dao.add_code(user_id=user.id, code='60456', code_type='email')
verify_codes_dao.add_code(user_id=user.id, code='27856', code_type='sms')
codes = verify_codes_dao.get_codes(user.id)
form = VerifyForm(codes)
assert form.validate() is True
def set_up_test_data():
user = create_test_user('pending')
verify_codes_dao.add_code(user_id=user.id, code='12345', code_type='email')
verify_codes_dao.add_code(user_id=user.id, code='12345', code_type='sms')
return user

40
tests/app/main/views/test_add_service.py
View File

@@ -1,36 +1,32 @@
from flask import url_for
from app.main.dao import verify_codes_dao, services_dao
from tests import create_test_user
from app.models import User
from app.main.dao import services_dao
def test_get_should_render_add_service_template(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service,
mock_get_services,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.get(url_for('main.add_service'))
assert response.status_code == 200
assert 'Set up notifications for your service' in response.get_data(as_text=True)
def test_should_add_service_and_redirect_to_next_page(app_,
db_,
db_session,
mock_create_service,
mock_get_services,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.post(
url_for('main.add_service'),
data={'name': 'testing the post'})
@@ -41,31 +37,29 @@ def test_should_add_service_and_redirect_to_next_page(app_,
def test_should_return_form_errors_when_service_name_is_empty(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service,
mock_get_services,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.post(url_for('main.add_service'), data={})
assert response.status_code == 200
assert 'Service name can not be empty' in response.get_data(as_text=True)
def test_should_return_form_errors_with_duplicate_service_name(app_,
db_,
db_session,
mock_get_services,
mock_user_loader,
mock_api_user,
mock_user_dao_get_by_email):
api_user_active,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.post(
url_for('main.add_service'), data={'name': 'service_one'})
assert response.status_code == 200

63
tests/app/main/views/test_api_keys.py
View File

@@ -3,29 +3,27 @@ from flask import url_for
def test_should_show_api_keys_and_documentation_page(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.get(url_for('main.documentation', service_id=123))
assert response.status_code == 200
def test_should_show_empty_api_keys_page(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email,
mock_get_no_api_keys):
mock_get_no_api_keys,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.get(url_for('main.api_keys', service_id=123))
assert response.status_code == 200
@@ -35,15 +33,14 @@ def test_should_show_empty_api_keys_page(app_,
def test_should_show_api_keys_page(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email,
mock_get_api_keys):
mock_get_api_keys,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.get(url_for('main.api_keys', service_id=123))
assert response.status_code == 200
@@ -54,31 +51,29 @@ def test_should_show_api_keys_page(app_,
def test_should_show_name_api_key_page(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email,
mock_get_api_keys):
mock_get_api_keys,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.get(url_for('main.create_api_key', service_id=123))
assert response.status_code == 200
def test_should_render_show_api_key(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email,
mock_create_api_key,
mock_get_api_keys):
mock_get_api_keys,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.post(url_for('main.create_api_key', service_id=123),
data={'key_name': 'some default key name'})
@@ -88,15 +83,14 @@ def test_should_render_show_api_key(app_,
def test_should_show_confirm_revoke_api_key(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email,
mock_get_api_keys):
mock_get_api_keys,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.get(url_for('main.revoke_api_key', service_id=123, key_id=321))
assert response.status_code == 200
@@ -105,16 +99,15 @@ def test_should_show_confirm_revoke_api_key(app_,
def test_should_redirect_after_revoking_api_key(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email,
mock_revoke_api_key,
mock_get_api_keys):
mock_get_api_keys,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.post(url_for('main.revoke_api_key', service_id=123, key_id=321))
assert response.status_code == 302

14
tests/app/main/views/test_choose_services.py
View File

@@ -1,20 +1,16 @@
from tests import create_test_user
from flask import url_for
from app.models import User
import pytest
@pytest.mark.xfail(reason='Requires completed move of user dao methods to api methods')
def test_should_show_choose_services_page(app_,
db_,
db_session,
active_user,
mock_get_services):
mock_user_dao_get_user,
api_user_active,
mock_get_services,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
user = User.query.first()
client.login(user)
client.login(api_user_active)
response = client.get(url_for('main.choose_service'))
assert response.status_code == 200

112
tests/app/main/views/test_code_not_received.py
View File

@@ -1,19 +1,19 @@
from app.main.dao import verify_codes_dao
from tests import create_test_api_user
from flask import url_for
def test_should_render_email_code_not_received_template_and_populate_email_address(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_api_user,
mock_user_dao_get_by_email):
api_user_active,
mock_user_dao_get_by_email,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.get(url_for('main.check_and_resend_email_code'))
assert response.status_code == 200
assert 'Check your email address is correct and then resend the confirmation code' \
@@ -22,18 +22,18 @@ def test_should_render_email_code_not_received_template_and_populate_email_addre
def test_should_check_and_resend_email_code_redirect_to_verify(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_api_user,
api_user_active,
mock_user_dao_get_by_email,
mock_user_dao_update_email):
mock_user_dao_update_email,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
verify_codes_dao.add_code(mock_api_user.id, code='12345', code_type='email')
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.post(url_for('main.check_and_resend_email_code'),
data={'email_address': 'test@user.gov.uk'})
assert response.status_code == 302
@@ -41,17 +41,17 @@ def test_should_check_and_resend_email_code_redirect_to_verify(app_,
def test_should_render_text_code_not_received_template(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_api_user,
mock_user_dao_get_by_email):
api_user_active,
mock_user_dao_get_by_email,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
verify_codes_dao.add_code(mock_api_user.id, code='12345', code_type='sms')
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.get(url_for('main.check_and_resend_text_code'))
assert response.status_code == 200
assert 'Check your mobile phone number is correct and then resend the confirmation code.' \
@@ -60,18 +60,18 @@ def test_should_render_text_code_not_received_template(app_,
def test_should_check_and_redirect_to_verify(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_api_user,
api_user_active,
mock_user_dao_get_by_email,
mock_user_dao_update_mobile):
mock_user_dao_update_mobile,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
verify_codes_dao.add_code(mock_api_user.id, code='12345', code_type='sms')
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.post(url_for('main.check_and_resend_text_code'),
data={'mobile_number': '+447700900460'})
assert response.status_code == 302
@@ -79,53 +79,54 @@ def test_should_check_and_redirect_to_verify(app_,
def test_should_update_email_address_resend_code(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_api_user,
api_user_active,
mock_user_dao_get_by_email,
mock_user_dao_update_email):
mock_user_dao_update_email,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
verify_codes_dao.add_code(user_id=mock_api_user.id, code='12345', code_type='email')
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.post(url_for('main.check_and_resend_email_code'),
data={'email_address': 'new@address.gov.uk'})
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
assert mock_api_user.email_address == 'new@address.gov.uk'
assert api_user_active.email_address == 'new@address.gov.uk'
def test_should_update_mobile_number_resend_code(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_api_user,
api_user_active,
mock_user_dao_get_by_email,
mock_user_dao_update_mobile):
mock_user_dao_update_mobile,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
verify_codes_dao.add_code(user_id=mock_api_user.id, code='12345', code_type='sms')
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.post(url_for('main.check_and_resend_text_code'),
data={'mobile_number': '+447700900460'})
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
assert mock_api_user.mobile_number == '+447700900460'
assert api_user_active.mobile_number == '+447700900460'
def test_should_render_verification_code_not_received(app_,
db_,
db_session,
mock_api_user):
api_user_active,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.get(url_for('main.verification_code_not_received'))
assert response.status_code == 200
assert 'Resend verification code' in response.get_data(as_text=True)
@@ -134,37 +135,34 @@ def test_should_render_verification_code_not_received(app_,
def test_check_and_redirect_to_two_factor(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_send_sms,
mock_send_email,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.get(url_for('main.check_and_resend_verification_code'))
assert response.status_code == 302
assert response.location == url_for('main.two_factor', _external=True)
def test_should_create_new_code_for_user(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_send_sms,
mock_send_email,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
verify_codes_dao.add_code(user_id=mock_api_user.id, code='12345', code_type='sms')
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.get(url_for('main.check_and_resend_verification_code'))
assert response.status_code == 302
assert response.location == url_for('main.two_factor', _external=True)
codes = verify_codes_dao.get_codes(user_id=mock_api_user.id, code_type='sms')
assert len(codes) == 2
for x in ([used.code_used for used in codes]):
assert x is False

10
tests/app/main/views/test_dashboard.py
View File

@@ -1,17 +1,15 @@
from app.models import User
from flask import url_for
def test_should_show_recent_jobs_on_dashboard(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.get(url_for('main.service_dashboard', service_id=123))
assert response.status_code == 200

10
tests/app/main/views/test_forgot_password.py
View File

@@ -3,7 +3,7 @@ from app.main.dao import users_dao
from tests import create_test_user
def test_should_render_forgot_password(app_, db_, db_session):
def test_should_render_forgot_password(app_):
with app_.test_request_context():
response = app_.test_client().get(url_for('.forgot_password'))
assert response.status_code == 200
@@ -12,18 +12,16 @@ def test_should_render_forgot_password(app_, db_, db_session):
def test_should_redirect_to_password_reset_sent_and_state_updated(app_,
db_,
db_session,
mock_send_email,
mock_api_user,
api_user_active,
mock_user_dao_get_by_email,
mock_user_dao_password_reset):
with app_.test_request_context():
response = app_.test_client().post(
url_for('.forgot_password'),
data={'email_address': mock_api_user.email_address})
data={'email_address': api_user_active.email_address})
assert response.status_code == 200
assert (
'You have been sent an email containing a link'
' to reset your password.') in response.get_data(as_text=True)
assert mock_api_user.state == 'request_password_reset'
assert api_user_active.state == 'request_password_reset'

31
tests/app/main/views/test_jobs.py
View File

@@ -1,27 +1,34 @@
from flask import url_for
from app.models import User
from tests import create_test_user
def test_should_return_list_of_all_jobs(app_, db_, db_session, service_one, mock_api_user,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_return_list_of_all_jobs(app_,
service_one,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.get(url_for('main.view_jobs', service_id=101))
assert response.status_code == 200
assert 'You haven’t sent any notifications yet' in response.get_data(as_text=True)
def test_should_show_page_for_one_job(app_, db_, db_session, service_one, mock_api_user,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_show_page_for_one_job(app_,
service_one,
api_user_active,
mock_login,
mock_user_loader,
mock_user_dao_get_by_email):
with app_.test_request_context():
with app_.test_client() as client:
# TODO filename will be part of job metadata not in session
with client.session_transaction() as s:
s[456] = 'dispatch_20151114.csv'
client.login(mock_api_user)
client.login(api_user_active)
response = client.get(url_for('main.view_job', service_id=123, job_id=456))
assert response.status_code == 200
@@ -29,11 +36,15 @@ def test_should_show_page_for_one_job(app_, db_, db_session, service_one, mock_a
assert 'Test message 1' in response.get_data(as_text=True)
def test_should_show_page_for_one_notification(app_, db_, db_session, service_one, mock_api_user,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_show_page_for_one_notification(app_,
service_one,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.get(url_for(
'main.view_notification',
service_id=101,

41
tests/app/main/views/test_new_password.py
View File

@@ -8,17 +8,19 @@ from tests import create_test_user
import pytest
def test_should_render_new_password_template(app_, db_, db_session, mock_api_user,
mock_user_dao_get_new_password):
def test_should_render_new_password_template(app_,
api_user_active,
mock_user_dao_get_new_password,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
token = generate_token(mock_api_user.email_address)
token = generate_token(api_user_active.email_address)
response = client.get(url_for('.new_password', token=token))
assert response.status_code == 200
assert ' You can now create a new password for your account.' in response.get_data(as_text=True)
# def test_should_render_new_password_template_with_message_of_bad_token(app_, db_, db_session,
# def test_should_render_new_password_template_with_message_of_bad_token(app_,
# mock_user_dao_get_by_email):
# with app_.test_request_context():
# with app_.test_client() as client:
@@ -31,15 +33,14 @@ def test_should_render_new_password_template(app_, db_, db_session, mock_api_use
@pytest.mark.xfail(reason='Password reset not implemented')
def test_should_redirect_to_two_factor_when_password_reset_is_successful(app_,
db_,
db_session,
mock_send_sms,
mock_api_user,
mock_user_dao_get_new_password):
api_user_active,
mock_user_dao_get_new_password,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
mock_api_user.state = 'request_password_reset'
token = generate_token(mock_api_user.email_address)
api_user_active.state = 'request_password_reset'
token = generate_token(api_user_active.email_address)
response = client.post(url_for('.new_password', token=token), data={'new_password': 'a-new_password'})
assert response.status_code == 302
assert response.location == url_for('.two_factor', _external=True)
@@ -49,14 +50,13 @@ def test_should_redirect_to_two_factor_when_password_reset_is_successful(app_,
def test_should_redirect_to_forgot_password_with_flash_message_when_token_is_expired(app_,
db_,
db_session,
mock_api_user):
api_user_active,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
app_.config['TOKEN_MAX_AGE_SECONDS'] = -1000
mock_api_user.state = 'request_password_reset'
token = generate_token(mock_api_user.email_address)
api_user_active.state = 'request_password_reset'
token = generate_token(api_user_active.email_address)
response = client.post(url_for('.new_password', token=token), data={'new_password': 'a-new_password'})
assert response.status_code == 302
assert response.location == url_for('.forgot_password', _external=True)
@@ -65,14 +65,13 @@ def test_should_redirect_to_forgot_password_with_flash_message_when_token_is_exp
@pytest.mark.xfail(reason='Password reset not implemented')
def test_should_redirect_to_forgot_pass_when_user_active_should_be_request_passw_reset(app_,
db_,
db_session,
mock_api_user,
mock_user_dao_get_by_email):
api_user_active,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
mock_api_user.state = 'request_password_reset'
token = generate_token(mock_api_user.email_address)
api_user_active.state = 'request_password_reset'
token = generate_token(api_user_active.email_address)
response = client.post(url_for('.new_password', token=token), data={'new_password': 'a-new_password'})
assert response.status_code == 302
assert response.location == url_for('.index', _external=True)

36
tests/app/main/views/test_register.py
View File

@@ -11,12 +11,10 @@ from tests.conftest import mock_register_user as mock_user
def test_process_register_creates_new_user(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_send_verify_code,
mock_register_user,
mock_user_by_email_not_found):
mock_user_by_email_not_found,
mock_login):
user_data = {
'name': 'Some One Valid',
'email_address': 'someone@example.gov.uk',
@@ -32,11 +30,9 @@ def test_process_register_creates_new_user(app_,
def test_process_register_returns_400_when_mobile_number_is_invalid(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_user_by_email_not_found):
mock_send_verify_code,
mock_user_by_email_not_found,
mock_login):
response = app_.test_client().post('/register',
data={'name': 'Bad Mobile',
'email_address': 'bad_mobile@example.gov.uk',
@@ -48,11 +44,9 @@ def test_process_register_returns_400_when_mobile_number_is_invalid(app_,
def test_should_return_400_when_email_is_not_gov_uk(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_user_by_email_not_found):
mock_send_verify_code,
mock_user_by_email_not_found,
mock_login):
response = app_.test_client().post('/register',
data={'name': 'Bad Mobile',
'email_address': 'bad_mobile@example.not.right',
@@ -64,13 +58,11 @@ def test_should_return_400_when_email_is_not_gov_uk(app_,
def test_should_add_verify_codes_on_session(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_send_verify_code,
mock_register_user,
mock_user_loader,
mock_user_by_email_not_found):
mock_user_by_email_not_found,
mock_login):
user_data = {
'name': 'Test Codes',
'email_address': 'test@example.gov.uk',
@@ -85,7 +77,9 @@ def test_should_add_verify_codes_on_session(app_,
assert 'notify_admin_session' in response.headers.get('Set-Cookie')
def test_should_return_400_if_password_is_blacklisted(app_, db_, db_session, mock_user_by_email_not_found):
def test_should_return_400_if_password_is_blacklisted(app_,
mock_user_by_email_not_found,
mock_login):
response = app_.test_client().post('/register',
data={'name': 'Bad Mobile',
'email_address': 'bad_mobile@example.not.right',

147
tests/app/main/views/test_service_settings.py
View File

@@ -1,11 +1,15 @@
from flask import (url_for, session)
def test_should_show_overview(app_, db_, db_session, mock_api_user, mock_get_service,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_show_overview(app_,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.get(url_for(
'main.service_settings', service_id=service_id))
@@ -16,11 +20,15 @@ def test_should_show_overview(app_, db_, db_session, mock_api_user, mock_get_ser
assert mock_get_service.called
def test_should_show_service_name(app_, db_, db_session, mock_api_user, mock_get_service,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_show_service_name(app_,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.get(url_for(
'main.service_name_change', service_id=service_id))
@@ -31,11 +39,15 @@ def test_should_show_service_name(app_, db_, db_session, mock_api_user, mock_get
service = mock_get_service.side_effect(service_id)['data']
def test_should_redirect_after_change_service_name(app_, db_, db_session, mock_api_user, mock_get_service,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_redirect_after_change_service_name(app_,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.post(url_for(
'main.service_name_change', service_id=service_id))
@@ -48,15 +60,14 @@ def test_should_redirect_after_change_service_name(app_, db_, db_session, mock_a
def test_should_show_service_name_confirmation(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.get(url_for(
'main.service_name_change_confirm', service_id=service_id))
@@ -68,16 +79,16 @@ def test_should_show_service_name_confirmation(app_,
def test_should_redirect_after_service_name_confirmation(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service,
mock_update_service,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login,
mock_verify_password):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
service_new_name = 'New Name'
with client.session_transaction() as session:
@@ -94,11 +105,15 @@ def test_should_redirect_after_service_name_confirmation(app_,
assert mock_update_service.called
def test_should_show_request_to_go_live(app_, db_, db_session, mock_api_user, mock_get_service,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_show_request_to_go_live(app_,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.get(
url_for('main.service_request_to_go_live', service_id=service_id))
@@ -110,16 +125,15 @@ def test_should_show_request_to_go_live(app_, db_, db_session, mock_api_user, mo
def test_should_redirect_after_request_to_go_live(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service,
mock_update_service,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.post(url_for(
'main.service_request_to_go_live', service_id=service_id))
@@ -132,11 +146,15 @@ def test_should_redirect_after_request_to_go_live(app_,
assert mock_update_service.called
def test_should_show_status_page(app_, db_, db_session, mock_api_user, mock_get_service,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_show_status_page(app_,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.get(url_for(
'main.service_status_change', service_id=service_id))
@@ -148,15 +166,14 @@ def test_should_show_status_page(app_, db_, db_session, mock_api_user, mock_get_
def test_should_show_redirect_after_status_change(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.post(url_for(
'main.service_status_change', service_id=service_id))
@@ -168,11 +185,15 @@ def test_should_show_redirect_after_status_change(app_,
assert mock_get_service.called
def test_should_show_status_confirmation(app_, db_, db_session, mock_api_user, mock_get_service,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_show_status_confirmation(app_,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.get(url_for(
'main.service_status_change_confirm', service_id=service_id))
@@ -184,16 +205,16 @@ def test_should_show_status_confirmation(app_, db_, db_session, mock_api_user, m
def test_should_redirect_after_status_confirmation(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service,
mock_update_service,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login,
mock_verify_password):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.post(url_for(
'main.service_status_change_confirm', service_id=service_id))
@@ -206,11 +227,15 @@ def test_should_redirect_after_status_confirmation(app_,
assert mock_update_service.called
def test_should_show_delete_page(app_, db_, db_session, mock_api_user, mock_get_service,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_show_delete_page(app_,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.get(url_for(
'main.service_delete', service_id=service_id))
@@ -220,11 +245,15 @@ def test_should_show_delete_page(app_, db_, db_session, mock_api_user, mock_get_
assert mock_get_service.called
def test_should_show_redirect_after_deleting_service(app_, db_, db_session, mock_api_user, mock_get_service,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_show_redirect_after_deleting_service(app_,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.post(url_for(
'main.service_delete', service_id=service_id))
@@ -235,11 +264,15 @@ def test_should_show_redirect_after_deleting_service(app_, db_, db_session, mock
assert delete_url == response.location
def test_should_show_delete_confirmation(app_, db_, db_session, mock_api_user, mock_get_service,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_show_delete_confirmation(app_,
api_user_active,
mock_get_service,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.get(url_for(
'main.service_delete_confirm', service_id=service_id))
@@ -250,16 +283,16 @@ def test_should_show_delete_confirmation(app_, db_, db_session, mock_api_user, m
def test_should_redirect_delete_confirmation(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service,
mock_delete_service,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login,
mock_verify_password):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.post(url_for(
'main.service_delete_confirm', service_id=service_id))

21
tests/app/main/views/test_sign_in.py
View File

@@ -1,7 +1,6 @@
from datetime import datetime
from app.main.dao import users_dao
from app.models import User
from flask import url_for
import pytest
@@ -18,14 +17,10 @@ def test_render_sign_in_returns_sign_in_template(app_):
def test_process_sign_in_return_2fa_template(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_user_dao_get_user,
mock_user_loader,
mock_user_dao_get_by_email,
mock_user_dao_checkpassword):
mock_send_verify_code,
mock_get_user,
mock_get_user_by_email,
mock_verify_password):
with app_.test_request_context():
response = app_.test_client().post(
url_for('main.sign_in'), data={
@@ -37,8 +32,6 @@ def test_process_sign_in_return_2fa_template(app_,
@pytest.mark.xfail(reason='User failed logins not implemented yet')
def test_should_return_locked_out_true_when_user_is_locked(app_,
db_,
db_session,
mock_user_dao_get_user,
mock_inactive_user_dao_get_by_email):
with app_.test_request_context():
@@ -66,8 +59,6 @@ def test_should_return_locked_out_true_when_user_is_locked(app_,
# @pytest.mark.xfail(reason='User failed logins not implemented yet')
# def test_should_return_active_user_is_false_if_user_is_inactive(app_,
# db_,
# db_session,
# mock_user_dao_get_user,
# mock_inactive_user_dao_get_by_email):
# with app_.test_request_context():
@@ -80,7 +71,7 @@ def test_should_return_locked_out_true_when_user_is_locked(app_,
# assert 'Username or password is incorrect' in response.get_data(as_text=True)
# def test_should_return_200_when_user_does_not_exist(app_, db_, db_session,
# def test_should_return_200_when_user_does_not_exist(app_,
# mock_user_dao_get_user,
# mock_user_dao_get_by_email):
# with app_.test_request_context():
@@ -92,7 +83,7 @@ def test_should_return_locked_out_true_when_user_is_locked(app_,
# assert 'Username or password is incorrect' in response.get_data(as_text=True)
# def test_should_return_200_when_user_is_not_active(app_, db_, db_session):
# def test_should_return_200_when_user_is_not_active(app_):
# user = User(email_address='PendingUser@example.gov.uk',
# password='val1dPassw0rd!',
# mobile_number='+441234123123',

10
tests/app/main/views/test_sign_out.py
View File

@@ -1,7 +1,6 @@
from datetime import datetime
from flask import url_for
from app.main.dao import users_dao
from app.models import User
def test_render_sign_out_redirects_to_sign_in(app_):
@@ -14,19 +13,18 @@ def test_render_sign_out_redirects_to_sign_in(app_):
def test_sign_out_user(app_,
db_,
db_session,
mock_send_sms,
mock_send_email,
mock_get_service,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
email = 'valid@example.gov.uk'
password = 'val1dPassw0rd!'
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
# Check we are logged in
response = client.get(
url_for('main.service_dashboard', service_id="123"))

45
tests/app/main/views/test_sms.py
View File

@@ -4,13 +4,14 @@ from flask import url_for
import moto
def test_upload_empty_csvfile_returns_to_upload_page(app_, db_, db_session,
mock_api_user,
def test_upload_empty_csvfile_returns_to_upload_page(app_,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
upload_data = {'file': (BytesIO(''.encode('utf-8')), 'emtpy.csv')}
response = client.post(url_for('main.send_sms', service_id=123),
data=upload_data, follow_redirects=True)
@@ -22,19 +23,18 @@ def test_upload_empty_csvfile_returns_to_upload_page(app_, db_, db_session,
@moto.mock_s3
def test_upload_csvfile_with_invalid_phone_shows_check_page_with_errors(app_,
db_,
db_session,
mocker,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
contents = 'phone\n+44 123\n+44 456'
file_data = (BytesIO(contents.encode('utf-8')), 'invalid.csv')
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
upload_data = {'file': file_data}
response = client.post(url_for('main.send_sms', service_id=123),
data=upload_data,
@@ -49,12 +49,11 @@ def test_upload_csvfile_with_invalid_phone_shows_check_page_with_errors(app_,
@moto.mock_s3
def test_upload_csvfile_with_valid_phone_shows_first3_and_last3_numbers(app_,
db_,
db_session,
mocker,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
contents = 'phone\n+44 7700 900981\n+44 7700 900982\n+44 7700 900983\n+44 7700 900984\n+44 7700 900985\n+44 7700 900986\n+44 7700 900987\n+44 7700 900988\n+44 7700 900989' # noqa
@@ -62,7 +61,7 @@ def test_upload_csvfile_with_valid_phone_shows_first3_and_last3_numbers(app_,
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
upload_data = {'file': file_data}
response = client.post(url_for('main.send_sms', service_id=123),
data=upload_data,
@@ -87,12 +86,11 @@ def test_upload_csvfile_with_valid_phone_shows_first3_and_last3_numbers(app_,
@moto.mock_s3
def test_upload_csvfile_with_valid_phone_shows_all_if_6_or_less_numbers(app_,
db_,
db_session,
mocker,
mock_api_user,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
contents = 'phone\n+44 7700 900981\n+44 7700 900982\n+44 7700 900983\n+44 7700 900984\n+44 7700 900985\n+44 7700 900986' # noqa
@@ -100,7 +98,7 @@ def test_upload_csvfile_with_valid_phone_shows_all_if_6_or_less_numbers(app_,
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
upload_data = {'file': file_data}
response = client.post(url_for('main.send_sms', service_id=123),
data=upload_data,
@@ -120,11 +118,14 @@ def test_upload_csvfile_with_valid_phone_shows_all_if_6_or_less_numbers(app_,
@moto.mock_s3
def test_should_redirect_to_job(app_, db_, db_session, mocker, mock_api_user,
mock_user_loader, mock_user_dao_get_by_email):
def test_should_redirect_to_job(app_,
api_user_active,
mock_user_loader,
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
response = client.post(url_for('main.check_sms',
service_id=123,
upload_id='someid'))

45
tests/app/main/views/test_templates.py
View File

@@ -3,15 +3,14 @@ from flask import url_for
def test_should_return_list_of_all_templates(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service_templates,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
response = client.get(url_for(
'.manage_service_templates', service_id=service_id))
@@ -21,15 +20,14 @@ def test_should_return_list_of_all_templates(app_,
def test_should_show_page_for_one_templates(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service_template,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
template_id = 456
response = client.get(url_for(
@@ -43,16 +41,15 @@ def test_should_show_page_for_one_templates(app_,
def test_should_redirect_when_saving_a_template(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service_template,
mock_update_service_template,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
template_id = 456
name = "new name"
@@ -78,15 +75,14 @@ def test_should_redirect_when_saving_a_template(app_,
def test_should_show_delete_template_page(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service_template,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
template_id = 456
response = client.get(url_for(
@@ -101,16 +97,15 @@ def test_should_show_delete_template_page(app_,
def test_should_redirect_when_deleting_a_template(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_get_service_template,
mock_delete_service_template,
mock_user_loader,
mock_user_dao_get_by_email):
mock_user_dao_get_by_email,
mock_login):
with app_.test_request_context():
with app_.test_client() as client:
client.login(mock_api_user)
client.login(api_user_active)
service_id = 123
template_id = 456
name = "new name"

53
tests/app/main/views/test_two_factor.py
View File

@@ -1,27 +1,35 @@
from flask import json, url_for
from app.main.dao import verify_codes_dao
from tests import create_test_user
def test_should_render_two_factor_page(app_, db_, db_session, mock_api_user, mock_user_dao_get_by_email):
def test_should_render_two_factor_page(app_,
api_user_active,
mock_user_dao_get_by_email):
with app_.test_request_context():
with app_.test_client() as client:
# TODO this lives here until we work out how to
# reassign the session after it is lost mid register process
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.get(url_for('main.two_factor'))
assert response.status_code == 200
assert '''We've sent you a text message with a verification code.''' in response.get_data(as_text=True)
def test_should_login_user_and_redirect_to_dashboard(app_, db_, db_session, mock_api_user, mock_user_dao_get_by_email):
def test_should_login_user_and_redirect_to_dashboard(app_,
api_user_active,
mock_get_user,
mock_user_dao_get_by_email,
mock_check_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
verify_codes_dao.add_code(user_id=mock_api_user.id, code='12345', code_type='sms')
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.post(url_for('main.two_factor'),
data={'sms_code': '12345'})
@@ -30,37 +38,32 @@ def test_should_login_user_and_redirect_to_dashboard(app_, db_, db_session, mock
def test_should_return_200_with_sms_code_error_when_sms_code_is_wrong(app_,
db_,
db_session,
mock_api_user,
mock_user_dao_get_by_email):
api_user_active,
mock_user_dao_get_by_email,
mock_check_verify_code_code_not_found):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
verify_codes_dao.add_code(user_id=mock_api_user.id, code='12345', code_type='sms')
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.post(url_for('main.two_factor'),
data={'sms_code': '23456'})
assert response.status_code == 200
assert 'Code does not match' in response.get_data(as_text=True)
assert 'Code not found' in response.get_data(as_text=True)
def test_should_login_user_when_multiple_valid_codes_exist(app_,
db_,
db_session,
mock_api_user,
mock_user_dao_get_by_email):
api_user_active,
mock_get_user,
mock_user_dao_get_by_email,
mock_check_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_email'] = mock_api_user.email_address
verify_codes_dao.add_code(user_id=mock_api_user.id, code='23456', code_type='sms')
verify_codes_dao.add_code(user_id=mock_api_user.id, code='12345', code_type='sms')
verify_codes_dao.add_code(user_id=mock_api_user.id, code='34567', code_type='sms')
assert len(verify_codes_dao.get_codes(user_id=mock_api_user.id, code_type='sms')) == 3
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.post(url_for('main.two_factor'),
data={'sms_code': '23456'})
assert response.status_code == 302
codes = verify_codes_dao.get_codes(user_id=mock_api_user.id, code_type='sms')
# query will only return codes where code_used == False
assert len(codes) == 0

321
tests/app/main/views/test_user_profile.py
View File

@@ -1,121 +1,292 @@
def test_should_show_overview_page(app_, db_, db_session):
response = app_.test_client().get('/user-profile')
assert 'Your profile' in response.get_data(as_text=True)
assert response.status_code == 200
import json
from flask import url_for
def test_should_show_name_page(app_, db_, db_session):
response = app_.test_client().get('/user-profile/name')
def test_should_show_overview_page(app_,
api_user_active,
mock_login,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.user_profile'))
assert 'Change your name' in response.get_data(as_text=True)
assert response.status_code == 200
assert 'Your profile' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_redirect_after_name_change(app_, db_, db_session):
response = app_.test_client().post('/user-profile/name')
def test_should_show_name_page(app_,
api_user_active,
mock_login,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.user_profile_name'))
assert response.status_code == 302
assert response.location == 'http://localhost/user-profile'
assert 'Change your name' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_show_email_page(app_, db_, db_session):
response = app_.test_client().get('/user-profile/email')
def test_should_redirect_after_name_change(app_,
api_user_active,
mock_login,
mock_update_user,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
new_name = 'New Name'
data = {'new_name': new_name}
response = client.post(url_for(
'main.user_profile_name'), data=data)
assert 'Change your email address' in response.get_data(as_text=True)
assert response.status_code == 200
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile', _external=True)
api_user_active.name = new_name
assert mock_update_user.called
def test_should_redirect_after_email_change(app_, db_, db_session):
response = app_.test_client().post('/user-profile/email')
def test_should_show_email_page(app_,
api_user_active,
mock_login,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for(
'main.user_profile_email'))
assert response.status_code == 302
assert response.location == 'http://localhost/user-profile/email/authenticate'
assert 'Change your email address' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_show_authenticate_after_email_change(app_, db_, db_session):
response = app_.test_client().get('/user-profile/email/authenticate')
def test_should_redirect_after_email_change(app_,
api_user_active,
mock_login,
mock_user_dao_get_user,
mock_get_user_by_email_not_found):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
data = {'email_address': 'new_notify@notify.gov.uk'}
response = client.post(
url_for('main.user_profile_email'),
data=data)
assert 'Change your email address' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile_email_authenticate', _external=True)
def test_should_redirect_after_email_change_confirm(app_, db_, db_session):
response = app_.test_client().post('/user-profile/email/authenticate')
def test_should_show_authenticate_after_email_change(app_,
api_user_active,
mock_login,
mock_user_dao_get_user,
mock_user_dao_checkpassword):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-email'] = 'new_notify@notify.gov.uk'
response = client.get(url_for('main.user_profile_email_authenticate'))
assert response.status_code == 302
assert response.location == 'http://localhost/user-profile/email/confirm'
assert 'Change your email address' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_show_confirm_after_email_change(app_, db_, db_session):
response = app_.test_client().get('/user-profile/email/confirm')
def test_should_redirect_after_email_change_confirm(app_,
api_user_active,
mock_login,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
data = {'email-code': '12345'}
with client.session_transaction() as session:
session['new-email'] = 'new_notify@notify.gov.uk'
response = client.post(
url_for('main.user_profile_email_authenticate'),
data=data)
assert 'Change your email address' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile_email_confirm', _external=True)
def test_should_redirect_after_email_change_confirm(app_, db_, db_session):
response = app_.test_client().post('/user-profile/email/confirm')
def test_should_show_confirm_after_email_change(app_,
api_user_active,
mock_login,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-email-password-confirmed'] = True
response = client.get(url_for('main.user_profile_email_confirm'))
assert response.status_code == 302
assert response.location == 'http://localhost/user-profile'
assert 'Change your email address' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_show_mobile_number_page(app_, db_, db_session):
response = app_.test_client().get('/user-profile/mobile-number')
def test_should_redirect_after_email_change_confirm(app_,
api_user_active,
mock_login,
mock_user_dao_get_user,
mock_check_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-email-password-confirmed'] = True
session['new-email'] = 'new_notify@notify.gov.uk'
data = {'email_code': '12345'}
response = client.post(
url_for('main.user_profile_email_confirm'),
data=data)
assert 'Change your mobile number' in response.get_data(as_text=True)
assert response.status_code == 200
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile', _external=True)
def test_should_redirect_after_mobile_number_change(app_, db_, db_session):
response = app_.test_client().post('/user-profile/email')
def test_should_show_mobile_number_page(app_,
api_user_active,
mock_login,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.user_profile_mobile_number'))
assert response.status_code == 302
assert response.location == 'http://localhost/user-profile/email/authenticate'
assert 'Change your mobile number' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_show_authenticate_after_mobile_number_change(app_, db_, db_session):
response = app_.test_client().get('/user-profile/mobile-number/authenticate')
assert 'Change your mobile number' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_redirect_after_mobile_number_change(app_,
api_user_active,
mock_login,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
data = {'mobile_number': '07121231234'}
response = client.post(
url_for('main.user_profile_mobile_number'),
data=data)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile_mobile_number_authenticate', _external=True)
def test_should_redirect_after_mobile_number_authenticate(app_, db_, db_session):
response = app_.test_client().post('/user-profile/mobile-number/authenticate')
def test_should_show_authenticate_after_mobile_number_change(app_,
api_user_active,
mock_login,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-mob'] = '+441234123123'
response = client.get(
url_for('main.user_profile_mobile_number_authenticate'))
assert response.status_code == 302
assert response.location == 'http://localhost/user-profile/mobile-number/confirm'
assert 'Change your mobile number' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_show_confirm_after_mobile_number_change(app_, db_, db_session):
response = app_.test_client().get('/user-profile/mobile-number/confirm')
def test_should_redirect_after_mobile_number_authenticate(app_,
api_user_active,
mock_login,
mock_user_dao_get_user,
mock_verify_password):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-mob'] = '+441234123123'
data = {'password': '12345667'}
response = client.post(
url_for('main.user_profile_mobile_number_authenticate'),
data=data)
assert 'Change your mobile number' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile_mobile_number_confirm', _external=True)
def test_should_redirect_after_mobile_number_confirm(app_, db_, db_session):
response = app_.test_client().post('/user-profile/mobile-number/confirm')
def test_should_show_confirm_after_mobile_number_change(app_,
api_user_active,
mock_login,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-mob-password-confirmed'] = True
response = client.get(
url_for('main.user_profile_mobile_number_confirm'))
assert response.status_code == 302
assert response.location == 'http://localhost/user-profile'
assert 'Change your mobile number' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_show_password_page(app_, db_, db_session):
response = app_.test_client().get('/user-profile/password')
assert 'Change your password' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_redirect_after_mobile_number_confirm(app_,
api_user_active,
mock_login,
mock_user_dao_get_user,
mock_check_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-mob-password-confirmed'] = True
session['new-mob'] = '+441234123123'
data = {'sms_code': '12345'}
response = client.post(
url_for('main.user_profile_mobile_number_confirm'),
data=data)
print(response.get_data(as_text=True))
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile', _external=True)
def test_should_redirect_after_password_change(app_, db_, db_session):
response = app_.test_client().post('/user-profile/password')
def test_should_show_password_page(app_,
api_user_active,
mock_login,
mock_user_dao_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.user_profile_password'))
assert response.status_code == 302
assert response.location == 'http://localhost/user-profile'
assert 'Change your password' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_redirect_after_password_change(app_,
api_user_active,
mock_login,
mock_get_user,
mock_update_user,
mock_verify_password):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
data = {
'new_password': '1234567890',
'old_password': '4567676328'}
response = client.post(
url_for('main.user_profile_password'),
data=data)
print(response.get_data(as_text=True))
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile', _external=True)

55
tests/app/main/views/test_verify.py
View File

@@ -1,17 +1,19 @@
from flask import json, url_for
from app.main.dao import users_dao, verify_codes_dao
from app.main.dao import users_dao
from tests import create_test_api_user
import pytest
def test_should_return_verify_template(app_, db_, db_session, mock_api_user):
def test_should_return_verify_template(app_,
api_user_active,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
# TODO this lives here until we work out how to
# reassign the session after it is lost mid register process
with client.session_transaction() as session:
session['user_details'] = {'email_address': mock_api_user.email_address, 'id': mock_api_user.id}
session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
response = client.get(url_for('main.verify'))
assert response.status_code == 200
assert (
@@ -20,18 +22,15 @@ def test_should_return_verify_template(app_, db_, db_session, mock_api_user):
def test_should_redirect_to_add_service_when_code_are_correct(app_,
db_,
db_session,
mock_api_user,
api_user_active,
mock_user_dao_get_user,
mock_activate_user,
mock_user_loader):
mock_user_loader,
mock_check_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {'email_address': mock_api_user.email_address, 'id': mock_api_user.id}
verify_codes_dao.add_code(user_id=mock_api_user.id, code='12345', code_type='sms')
verify_codes_dao.add_code(user_id=mock_api_user.id, code='23456', code_type='email')
session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
response = client.post(url_for('main.verify'),
data={'sms_code': '12345',
'email_code': '23456'})
@@ -39,47 +38,45 @@ def test_should_redirect_to_add_service_when_code_are_correct(app_,
assert response.location == url_for('main.add_service', first='first', _external=True)
# def test_should_activate_user_after_verify(app_, db_, db_session, mock_api_user, mock_activate_user):
# def test_should_activate_user_after_verify(app_, api_user_active, mock_activate_user):
# with app_.test_request_context():
# with app_.test_client() as client:
# with client.session_transaction() as session:
# session['user_details'] = {'email_address': mock_api_user.email_address, 'id': mock_api_user.id}
# verify_codes_dao.add_code(user_id=mock_api_user.id, code='12345', code_type='sms')
# verify_codes_dao.add_code(user_id=mock_api_user.id, code='23456', code_type='email')
# session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
# verify_codes_dao.add_code(user_id=api_user_active.id, code='12345', code_type='sms')
# verify_codes_dao.add_code(user_id=api_user_active.id, code='23456', code_type='email')
# client.post(url_for('main.verify'),
# data={'sms_code': '12345',
# 'email_code': '23456'})
# assert mock_api_user.state == 'active'
# assert api_user_active.state == 'active'
def test_should_return_200_when_codes_are_wrong(app_, db_, db_session, mock_api_user, mock_user_dao_get_user):
def test_should_return_200_when_codes_are_wrong(app_,
api_user_active,
mock_user_dao_get_user,
mock_check_verify_code_code_not_found):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {'email_address': mock_api_user.email_address, 'id': mock_api_user.id}
verify_codes_dao.add_code(user_id=mock_api_user.id, code='23345', code_type='sms')
verify_codes_dao.add_code(user_id=mock_api_user.id, code='98456', code_type='email')
session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
response = client.post(url_for('main.verify'),
data={'sms_code': '12345',
'email_code': '23456'})
print(response.location)
assert response.status_code == 200
resp_data = response.get_data(as_text=True)
assert resp_data.count('Code does not match') == 2
assert resp_data.count('Code not found') == 2
# def test_should_mark_all_codes_as_used_when_many_codes_exist(app_,
# db_,
# db_session,
# mock_api_user):
# api_user_active):
# with app_.test_request_context():
# with app_.test_client() as client:
# with client.session_transaction() as session:
# session['user_details'] = {'email_address': mock_api_user.email_address, 'id': mock_api_user.id}
# code1 = verify_codes_dao.add_code(user_id=mock_api_user.id, code='23345', code_type='sms')
# code2 = verify_codes_dao.add_code(user_id=mock_api_user.id, code='98456', code_type='email')
# code3 = verify_codes_dao.add_code(user_id=mock_api_user.id, code='12345', code_type='sms')
# code4 = verify_codes_dao.add_code(user_id=mock_api_user.id, code='23412', code_type='email')
# session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
# code1 = verify_codes_dao.add_code(user_id=api_user_active.id, code='23345', code_type='sms')
# code2 = verify_codes_dao.add_code(user_id=api_user_active.id, code='98456', code_type='email')
# code3 = verify_codes_dao.add_code(user_id=api_user_active.id, code='12345', code_type='sms')
# code4 = verify_codes_dao.add_code(user_id=api_user_active.id, code='23412', code_type='email')
# response = client.post(url_for('main.verify'),
# data={'sms_code': '23345',
# 'email_code': '23412'})