darkhelm/notifications-admin
1
0
Fork 0
mirror of https://github.com/GSA/notifications-admin.git synced 2026-07-16 03:10:16 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
4d0da6594de60fcf37dc7796279462e32072d7a1
notifications-admin/tests/app/main/views/test_forgot_password.py

52 lines
1.8 KiB
Python
Raw Normal View History

Update forgotten password to allow non-gov with test
2016-10-26 14:01:01 +01:00
import pytest
Enforce order and style of imports Done using isort[1], with the following command: ``` isort -rc ./app ./tests ``` Adds linting to the `run_tests.sh` script to stop badly-sorted imports getting re-introduced. Chosen style is ‘Vertical Hanging Indent’ with trailing commas, because I think it gives the cleanest diffs, eg: ``` from third_party import ( lib1, lib2, lib3, lib4, ) ``` 1. https://pypi.python.org/pypi/isort
2018-02-20 11:22:17 +00:00
from flask import Response, url_for
Should show the sent password reset link page when the user is not found.
2016-03-16 14:19:41 +00:00
from notifications_python_client.errors import HTTPError
Add endpoints for forgot-password.
2016-01-04 14:00:39 +00:00
Revert config changes so it doesn't break local dev builds. Update tests
2016-03-09 09:29:35 +00:00
import app
Stop the user fixtures being called as a functions from conftest Stopped fixtures in conftest.py from calling the fixtures which return user json as if they were functions. Deleted two fixtures that are now no longer needed as a result of the changes to conftest.py.
2019-12-19 10:22:45 +00:00
from tests import user_json
Revert config changes so it doesn't break local dev builds. Update tests
2016-03-09 09:29:35 +00:00
Add endpoints for forgot-password.
2016-01-04 14:00:39 +00:00
Use `client` and `logged_in_client` fixtures Wherever possible, because Don’t Repeat Yourself.
2017-02-03 12:07:21 +00:00
def test_should_render_forgot_password(client):
response = client.get(url_for('.forgot_password'))
assert response.status_code == 200
assert 'We’ll send you an email to create a new password.' \
in response.get_data(as_text=True)
Add endpoints for forgot-password.
2016-01-04 14:00:39 +00:00
Update forgotten password to allow non-gov with test
2016-10-26 14:01:01 +01:00
@pytest.mark.parametrize('email_address', [
'test@user.gov.uk',
Correct whitelist to non-government in test name See c31264d4c for why ‘whitelist’ should be avoided. The use of whitelist here was not referring to the user-maintained list, but to mean ‘not a government’ email address. This commit renames these tests to make that difference clear.
2020-06-12 09:15:23 +01:00
'someuser@notgovernment.com'
Update forgotten password to allow non-gov with test
2016-10-26 14:01:01 +01:00
])
Re-implement forgot password
2016-03-07 18:18:52 +00:00
def test_should_redirect_to_password_reset_sent_for_valid_email(
Use `client` and `logged_in_client` fixtures Wherever possible, because Don’t Repeat Yourself.
2017-02-03 12:07:21 +00:00
client,
Normalize whitespace in test arguments We have a bunch of different styles of handling when function definitions span multiple lines, which they almost always do with tests. Here’s why an argument per line, single indent is best: - cleaner diffs when you change the name of a method (one line change instead of multiple lines) - works better on narrow screens, eg Github’s diff view, or with two terminals side by side on a laptop screen - works with any editor’s indenting shortcuts, no need for an IDE Also, trailing comma in the list of arguments is good because adding a new argument to a method becomes a one line, not two line diff.
2017-02-03 10:42:01 +00:00
fake_uuid,
email_address,
mocker,
):
Stop the user fixtures being called as a functions from conftest Stopped fixtures in conftest.py from calling the fixtures which return user json as if they were functions. Deleted two fixtures that are now no longer needed as a result of the changes to conftest.py.
2019-12-19 10:22:45 +00:00
sample_user = user_json(email_address=email_address)
Use `client` and `logged_in_client` fixtures Wherever possible, because Don’t Repeat Yourself.
2017-02-03 12:07:21 +00:00
mocker.patch('app.user_api_client.send_reset_password_url', return_value=None)
response = client.post(
url_for('.forgot_password'),
Make user API client return JSON, not a model The data flow of other bits of our application looks like this: ``` API (returns JSON) ⬇ API client (returns a built in type, usually `dict`) ⬇ Model (returns an instance, eg of type `Service`) ⬇ View (returns HTML) ``` The user API client was architected weirdly, in that it returned a model directly, like this: ``` API (returns JSON) ⬇ API client (returns a model, of type `User`, `InvitedUser`, etc) ⬇ View (returns HTML) ``` This mixing of different layers of the application is bad because it makes it hard to write model code that doesn’t have circular dependencies. As our application gets more complicated we will be relying more on models to manage this complexity, so we should make it easy, not hard to write them. It also means that most of our mocking was of the User model, not just the underlying JSON. So it would have been easy to introduce subtle bugs to the user model, because it wasn’t being comprehensively tested. A lot of the changed lines of code in this commit mean changing the tests to mock only the JSON, which means that the model layer gets implicitly tested. For those reasons this commit changes the user API client to return JSON, not an instance of `User` or other models.
2019-05-23 15:27:35 +01:00
data={'email_address': sample_user['email_address']})
Use `client` and `logged_in_client` fixtures Wherever possible, because Don’t Repeat Yourself.
2017-02-03 12:07:21 +00:00
assert response.status_code == 200
assert 'Click the link in the email to reset your password.' \
in response.get_data(as_text=True)
Make user API client return JSON, not a model The data flow of other bits of our application looks like this: ``` API (returns JSON) ⬇ API client (returns a built in type, usually `dict`) ⬇ Model (returns an instance, eg of type `Service`) ⬇ View (returns HTML) ``` The user API client was architected weirdly, in that it returned a model directly, like this: ``` API (returns JSON) ⬇ API client (returns a model, of type `User`, `InvitedUser`, etc) ⬇ View (returns HTML) ``` This mixing of different layers of the application is bad because it makes it hard to write model code that doesn’t have circular dependencies. As our application gets more complicated we will be relying more on models to manage this complexity, so we should make it easy, not hard to write them. It also means that most of our mocking was of the User model, not just the underlying JSON. So it would have been easy to introduce subtle bugs to the user model, because it wasn’t being comprehensively tested. A lot of the changed lines of code in this commit mean changing the tests to mock only the JSON, which means that the model layer gets implicitly tested. For those reasons this commit changes the user API client to return JSON, not an instance of `User` or other models.
2019-05-23 15:27:35 +01:00
app.user_api_client.send_reset_password_url.assert_called_once_with(sample_user['email_address'])
Should show the sent password reset link page when the user is not found.
2016-03-16 14:19:41 +00:00
def test_should_redirect_to_password_reset_sent_for_missing_email(
Use `client` and `logged_in_client` fixtures Wherever possible, because Don’t Repeat Yourself.
2017-02-03 12:07:21 +00:00
client,
Normalize whitespace in test arguments We have a bunch of different styles of handling when function definitions span multiple lines, which they almost always do with tests. Here’s why an argument per line, single indent is best: - cleaner diffs when you change the name of a method (one line change instead of multiple lines) - works better on narrow screens, eg Github’s diff view, or with two terminals side by side on a laptop screen - works with any editor’s indenting shortcuts, no need for an IDE Also, trailing comma in the list of arguments is good because adding a new argument to a method becomes a one line, not two line diff.
2017-02-03 10:42:01 +00:00
api_user_active,
mocker,
):
Use `client` and `logged_in_client` fixtures Wherever possible, because Don’t Repeat Yourself.
2017-02-03 12:07:21 +00:00
mocker.patch('app.user_api_client.send_reset_password_url', side_effect=HTTPError(Response(status=404),
'Not found'))
response = client.post(
url_for('.forgot_password'),
Make user API client return JSON, not a model The data flow of other bits of our application looks like this: ``` API (returns JSON) ⬇ API client (returns a built in type, usually `dict`) ⬇ Model (returns an instance, eg of type `Service`) ⬇ View (returns HTML) ``` The user API client was architected weirdly, in that it returned a model directly, like this: ``` API (returns JSON) ⬇ API client (returns a model, of type `User`, `InvitedUser`, etc) ⬇ View (returns HTML) ``` This mixing of different layers of the application is bad because it makes it hard to write model code that doesn’t have circular dependencies. As our application gets more complicated we will be relying more on models to manage this complexity, so we should make it easy, not hard to write them. It also means that most of our mocking was of the User model, not just the underlying JSON. So it would have been easy to introduce subtle bugs to the user model, because it wasn’t being comprehensively tested. A lot of the changed lines of code in this commit mean changing the tests to mock only the JSON, which means that the model layer gets implicitly tested. For those reasons this commit changes the user API client to return JSON, not an instance of `User` or other models.
2019-05-23 15:27:35 +01:00
data={'email_address': api_user_active['email_address']})
Use `client` and `logged_in_client` fixtures Wherever possible, because Don’t Repeat Yourself.
2017-02-03 12:07:21 +00:00
assert response.status_code == 200
assert 'Click the link in the email to reset your password.' \
in response.get_data(as_text=True)
Make user API client return JSON, not a model The data flow of other bits of our application looks like this: ``` API (returns JSON) ⬇ API client (returns a built in type, usually `dict`) ⬇ Model (returns an instance, eg of type `Service`) ⬇ View (returns HTML) ``` The user API client was architected weirdly, in that it returned a model directly, like this: ``` API (returns JSON) ⬇ API client (returns a model, of type `User`, `InvitedUser`, etc) ⬇ View (returns HTML) ``` This mixing of different layers of the application is bad because it makes it hard to write model code that doesn’t have circular dependencies. As our application gets more complicated we will be relying more on models to manage this complexity, so we should make it easy, not hard to write them. It also means that most of our mocking was of the User model, not just the underlying JSON. So it would have been easy to introduce subtle bugs to the user model, because it wasn’t being comprehensively tested. A lot of the changed lines of code in this commit mean changing the tests to mock only the JSON, which means that the model layer gets implicitly tested. For those reasons this commit changes the user API client to return JSON, not an instance of `User` or other models.
2019-05-23 15:27:35 +01:00
app.user_api_client.send_reset_password_url.assert_called_once_with(api_user_active['email_address'])
Reference in New Issue Copy Permalink