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

notify-api-412 use black to enforce python coding style

Browse Source
This commit is contained in:
Kenneth Kehl
2023-08-25 09:12:23 -07:00
parent c6eb007386
commit 8c9721d8e2
201 changed files with 31660 additions and 28105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
tests/app/main/forms/test_choose_time_form.py
View File

@@ -6,42 +6,42 @@ from app.main.forms import ChooseTimeForm
@freeze_time("2016-01-01 11:09:00.061258")
def test_form_contains_next_24h(notify_admin):
choices = ChooseTimeForm().scheduled_for.choices
# Friday
assert choices[0] == ('', 'Now')
assert choices[1] == ('2016-01-01T12:00:00', 'Today at noon UTC')
assert choices[13] == ('2016-01-02T00:00:00', 'Today at midnight UTC')
assert choices[0] == ("", "Now")
assert choices[1] == ("2016-01-01T12:00:00", "Today at noon UTC")
assert choices[13] == ("2016-01-02T00:00:00", "Today at midnight UTC")
# Saturday
assert choices[14] == ('2016-01-02T01:00:00', 'Tomorrow at 1am UTC')
assert choices[37] == ('2016-01-03T00:00:00', 'Tomorrow at midnight UTC')
assert choices[14] == ("2016-01-02T01:00:00", "Tomorrow at 1am UTC")
assert choices[37] == ("2016-01-03T00:00:00", "Tomorrow at midnight UTC")
# Sunday
assert choices[38] == ('2016-01-03T01:00:00', 'Sunday at 1am UTC')
assert choices[38] == ("2016-01-03T01:00:00", "Sunday at 1am UTC")
# Monday
assert choices[62] == ('2016-01-04T01:00:00', 'Monday at 1am UTC')
assert choices[80] == ('2016-01-04T19:00:00', 'Monday at 7pm UTC')
assert choices[84] == ('2016-01-04T23:00:00', 'Monday at 11pm UTC')
assert choices[85] == ('2016-01-05T00:00:00', 'Monday at midnight UTC')
assert choices[62] == ("2016-01-04T01:00:00", "Monday at 1am UTC")
assert choices[80] == ("2016-01-04T19:00:00", "Monday at 7pm UTC")
assert choices[84] == ("2016-01-04T23:00:00", "Monday at 11pm UTC")
assert choices[85] == ("2016-01-05T00:00:00", "Monday at midnight UTC")
with pytest.raises(IndexError):
assert choices[
12 + # hours left in the day
(3 * 24) + # 3 days
2 # magic number
12 + (3 * 24) + 2 # hours left in the day # 3 days # magic number
]
@freeze_time("2016-01-01 11:09:00.061258")
def test_form_defaults_to_now(notify_admin):
assert ChooseTimeForm().scheduled_for.data == ''
assert ChooseTimeForm().scheduled_for.data == ""
@freeze_time("2016-01-01 11:09:00.061258")
def test_form_contains_next_three_days(notify_admin):
assert ChooseTimeForm().scheduled_for.categories == [
'Later today', 'Tomorrow', 'Sunday', 'Monday'
"Later today",
"Tomorrow",
"Sunday",
"Monday",
]

47
tests/app/main/forms/test_create_key_form.py
View File

@@ -4,10 +4,13 @@ from werkzeug.datastructures import MultiDict
from app.main.forms import CreateKeyForm
@pytest.mark.parametrize('expiry_date, expected_errors', (
(None, ['A key with this name already exists']),
('2001-01-01 01:01:01', None),
))
@pytest.mark.parametrize(
"expiry_date, expected_errors",
(
(None, ["A key with this name already exists"]),
("2001-01-01 01:01:01", None),
),
)
def test_return_validation_error_when_key_name_exists(
client_request,
expiry_date,
@@ -15,36 +18,32 @@ def test_return_validation_error_when_key_name_exists(
):
_existing_keys = [
{
'name': 'some key',
'expiry_date': expiry_date,
"name": "some key",
"expiry_date": expiry_date,
},
{
'name': 'another key',
'expiry_date': None,
"name": "another key",
"expiry_date": None,
},
]
form = CreateKeyForm(
_existing_keys,
formdata=MultiDict([('key_name', 'Some key')])
)
form = CreateKeyForm(_existing_keys, formdata=MultiDict([("key_name", "Some key")]))
form.key_type.choices = [('a', 'a'), ('b', 'b')]
form.key_type.choices = [("a", "a"), ("b", "b")]
form.validate()
assert form.errors.get('key_name') == expected_errors
assert form.errors.get("key_name") == expected_errors
@pytest.mark.parametrize(
'key_type, expected_error', [
('', 'Select the type of key'),
('invalid', 'Select the type of key')
]
"key_type, expected_error",
[("", "Select the type of key"), ("invalid", "Select the type of key")],
)
def test_return_validation_error_when_key_type_not_chosen(client_request, key_type, expected_error):
def test_return_validation_error_when_key_type_not_chosen(
client_request, key_type, expected_error
):
form = CreateKeyForm(
[],
formdata=MultiDict([('key_name', 'Some key'), ('key_type', key_type)]))
form.key_type.choices = [('a', 'a'), ('b', 'b')]
[], formdata=MultiDict([("key_name", "Some key"), ("key_type", key_type)])
)
form.key_type.choices = [("a", "a"), ("b", "b")]
form.validate()
assert form.errors['key_type'] == [expected_error]
assert form.errors["key_type"] == [expected_error]

80
tests/app/main/forms/test_placeholder_form.py
View File

@@ -4,46 +4,59 @@ from app.main.forms import get_placeholder_form_instance
def test_form_class_not_mutated(notify_admin):
with notify_admin.test_request_context(
method='POST',
data={'placeholder_value': ''}
method="POST", data={"placeholder_value": ""}
):
form1 = get_placeholder_form_instance('name', {}, 'sms')
form2 = get_placeholder_form_instance('city', {}, 'sms')
form1 = get_placeholder_form_instance("name", {}, "sms")
form2 = get_placeholder_form_instance("city", {}, "sms")
assert not form1.validate_on_submit()
assert not form2.validate_on_submit()
assert str(form1.placeholder_value.label) == '<label for="placeholder_value">name</label>'
assert str(form2.placeholder_value.label) == '<label for="placeholder_value">city</label>'
assert (
str(form1.placeholder_value.label)
== '<label for="placeholder_value">name</label>'
)
assert (
str(form2.placeholder_value.label)
== '<label for="placeholder_value">city</label>'
)
@pytest.mark.parametrize('service_can_send_international_sms, placeholder_name, template_type, value, expected_error', [
(False, 'email address', 'email', '', 'Cannot be empty'),
(False, 'email address', 'email', '12345', 'Enter a valid email address'),
(False, 'email address', 'email', '“bad”@email-address.com', 'Enter a valid email address'),
(False, 'email address', 'email', 'test@example.com', None),
(False, 'email address', 'email', 'test@example.gsa.gov', None),
(False, 'phone number', 'sms', '', 'Cannot be empty'),
(False, 'phone number', 'sms', '+(44) 7700-900 855', 'Not a US number'),
(False, 'phone number', 'sms', '2028675309', None),
(False, 'phone number', 'sms', '+1 (202) 867-5309', None),
(True, 'phone number', 'sms', '+123', 'Not enough digits'),
(True, 'phone number', 'sms', '+44(0)7900 900-123', None),
(True, 'phone number', 'sms', '+1-2345-678890', None),
(False, 'anything else', 'sms', '', 'Cannot be empty'),
(False, 'anything else', 'email', '', 'Cannot be empty'),
(True, 'phone number', 'sms', 'invalid', 'The string supplied did not seem to be a phone number.'),
(True, 'phone number', 'email', 'invalid', None),
(True, 'email address', 'sms', 'invalid', None),
])
@pytest.mark.parametrize(
"service_can_send_international_sms, placeholder_name, template_type, value, expected_error",
[
(False, "email address", "email", "", "Cannot be empty"),
(False, "email address", "email", "12345", "Enter a valid email address"),
(
False,
"email address",
"email",
"“bad”@email-address.com",
"Enter a valid email address",
),
(False, "email address", "email", "test@example.com", None),
(False, "email address", "email", "test@example.gsa.gov", None),
(False, "phone number", "sms", "", "Cannot be empty"),
(False, "phone number", "sms", "+(44) 7700-900 855", "Not a US number"),
(False, "phone number", "sms", "2028675309", None),
(False, "phone number", "sms", "+1 (202) 867-5309", None),
(True, "phone number", "sms", "+123", "Not enough digits"),
(True, "phone number", "sms", "+44(0)7900 900-123", None),
(True, "phone number", "sms", "+1-2345-678890", None),
(False, "anything else", "sms", "", "Cannot be empty"),
(False, "anything else", "email", "", "Cannot be empty"),
(
True,
"phone number",
"sms",
"invalid",
"The string supplied did not seem to be a phone number.",
),
(True, "phone number", "email", "invalid", None),
(True, "email address", "sms", "invalid", None),
],
)
def test_validates_recipients(
notify_admin,
placeholder_name,
@@ -53,8 +66,7 @@ def test_validates_recipients(
expected_error,
):
with notify_admin.test_request_context(
method='POST',
data={'placeholder_value': value}
method="POST", data={"placeholder_value": value}
):
form = get_placeholder_form_instance(
placeholder_name,

31
tests/app/main/forms/test_register_user_form.py
View File

@@ -3,31 +3,29 @@ import pytest
from app.main.forms import RegisterUserForm
@pytest.mark.parametrize('password', [
'usnotify'
])
@pytest.mark.parametrize("password", ["usnotify"])
def test_should_raise_validation_error_for_password(
client_request,
mock_get_user_by_email,
password,
):
form = RegisterUserForm()
form.name.data = 'test'
form.email_address.data = 'teset@gsa.gov'
form.mobile_number.data = '2021231231'
form.name.data = "test"
form.email_address.data = "teset@gsa.gov"
form.mobile_number.data = "2021231231"
form.password.data = password
form.validate()
assert 'Choose a password that’s harder to guess' in form.errors['password']
assert "Choose a password that’s harder to guess" in form.errors["password"]
def test_valid_email_not_in_valid_domains(
client_request,
mock_get_organizations,
):
form = RegisterUserForm(email_address="test@test.com", mobile_number='2021231231')
form = RegisterUserForm(email_address="test@test.com", mobile_number="2021231231")
assert not form.validate()
assert "Enter a public sector email address" in form.errors['email_address'][0]
assert "Enter a public sector email address" in form.errors["email_address"][0]
def test_valid_email_in_valid_domains(
@@ -36,8 +34,9 @@ def test_valid_email_in_valid_domains(
form = RegisterUserForm(
name="test",
email_address="test@gsa.gov",
mobile_number='2028675309',
password='an uncommon password')
mobile_number="2028675309",
password="an uncommon password",
)
form.validate()
assert form.errors == {}
@@ -49,13 +48,15 @@ def test_invalid_email_address_error_message(
form = RegisterUserForm(
name="test",
email_address="test.com",
mobile_number='2028675309',
password='1234567890')
mobile_number="2028675309",
password="1234567890",
)
assert not form.validate()
form = RegisterUserForm(
name="test",
email_address="test.com",
mobile_number='+12028675309',
password='1234567890')
mobile_number="+12028675309",
password="1234567890",
)
assert not form.validate()

84
tests/app/main/forms/test_service_contact_details_form.py
View File

@@ -4,43 +4,49 @@ from app.main.forms import ServiceContactDetailsForm
def test_form_fails_validation_with_no_radio_buttons_selected(notify_admin):
with notify_admin.test_request_context(method='POST', data={}):
with notify_admin.test_request_context(method="POST", data={}):
form = ServiceContactDetailsForm()
assert not form.validate_on_submit()
assert len(form.errors) == 1
assert form.errors['contact_details_type'] == ['Select an option']
assert form.errors["contact_details_type"] == ["Select an option"]
@pytest.mark.parametrize('selected_radio_button, selected_text_box, text_box_data', [
('email_address', 'url', 'http://www.example.com'),
('phone_number', 'url', 'http://www.example.com'),
('url', 'email_address', 'user@example.com'),
('phone_number', 'email_address', 'user@example.com'),
('url', 'phone_number', '202 867 5309'),
('email_address', 'phone_number', '202 867 5309'),
])
@pytest.mark.parametrize(
"selected_radio_button, selected_text_box, text_box_data",
[
("email_address", "url", "http://www.example.com"),
("phone_number", "url", "http://www.example.com"),
("url", "email_address", "user@example.com"),
("phone_number", "email_address", "user@example.com"),
("url", "phone_number", "202 867 5309"),
("email_address", "phone_number", "202 867 5309"),
],
)
def test_form_fails_validation_when_radio_button_selected_and_text_box_filled_in_do_not_match(
notify_admin,
selected_radio_button,
selected_text_box,
text_box_data
notify_admin, selected_radio_button, selected_text_box, text_box_data
):
data = {'contact_details_type': selected_radio_button, selected_text_box: text_box_data}
data = {
"contact_details_type": selected_radio_button,
selected_text_box: text_box_data,
}
with notify_admin.test_request_context(method='POST', data=data):
with notify_admin.test_request_context(method="POST", data=data):
form = ServiceContactDetailsForm()
assert not form.validate_on_submit()
assert len(form.errors) == 1
assert form.errors[selected_radio_button] == ['This field is required.']
assert form.errors[selected_radio_button] == ["This field is required."]
@pytest.mark.parametrize('selected_field, url, email_address, phone_number', [
('url', 'http://www.example.com', 'invalid-email.com', 'phone'),
('email_address', 'www.invalid-url.com', 'me@example.com', 'phone'),
('phone_number', 'www.invalid-url.com', 'invalid-email.com', '202 867 5309'),
])
@pytest.mark.parametrize(
"selected_field, url, email_address, phone_number",
[
("url", "http://www.example.com", "invalid-email.com", "phone"),
("email_address", "www.invalid-url.com", "me@example.com", "phone"),
("phone_number", "www.invalid-url.com", "invalid-email.com", "202 867 5309"),
],
)
def test_form_only_validates_the_field_which_matches_the_selected_radio_button(
notify_admin,
selected_field,
@@ -48,45 +54,49 @@ def test_form_only_validates_the_field_which_matches_the_selected_radio_button(
email_address,
phone_number,
):
data = {'contact_details_type': selected_field,
'url': url,
'email_address': email_address,
'phone_number': phone_number}
data = {
"contact_details_type": selected_field,
"url": url,
"email_address": email_address,
"phone_number": phone_number,
}
with notify_admin.test_request_context(method='POST', data=data):
with notify_admin.test_request_context(method="POST", data=data):
form = ServiceContactDetailsForm()
assert form.validate_on_submit()
def test_form_url_validation_fails_with_invalid_url_field(notify_admin):
data = {'contact_details_type': 'url', 'url': 'www.example.com'}
data = {"contact_details_type": "url", "url": "www.example.com"}
with notify_admin.test_request_context(method='POST', data=data):
with notify_admin.test_request_context(method="POST", data=data):
form = ServiceContactDetailsForm()
assert not form.validate_on_submit()
assert len(form.errors) == 1
assert len(form.errors['url']) == 1
assert len(form.errors["url"]) == 1
def test_form_email_validation_fails_with_invalid_email_address_field(notify_admin):
data = {'contact_details_type': 'email_address', 'email_address': '1@co'}
data = {"contact_details_type": "email_address", "email_address": "1@co"}
with notify_admin.test_request_context(method='POST', data=data):
with notify_admin.test_request_context(method="POST", data=data):
form = ServiceContactDetailsForm()
assert not form.validate_on_submit()
assert len(form.errors) == 1
assert len(form.errors['email_address']) == 2
assert len(form.errors["email_address"]) == 2
def test_form_phone_number_validation_fails_with_invalid_phone_number_field(notify_admin):
data = {'contact_details_type': 'phone_number', 'phone_number': '1235 A'}
def test_form_phone_number_validation_fails_with_invalid_phone_number_field(
notify_admin,
):
data = {"contact_details_type": "phone_number", "phone_number": "1235 A"}
with notify_admin.test_request_context(method='POST', data=data):
with notify_admin.test_request_context(method="POST", data=data):
form = ServiceContactDetailsForm()
assert not form.validate_on_submit()
assert len(form.errors) == 1
assert form.errors['phone_number'] == ['Must be a valid phone number']
assert form.errors["phone_number"] == ["Must be a valid phone number"]

28
tests/app/main/forms/test_service_sms_senders_form.py
View File

@@ -6,24 +6,20 @@ from app.main.forms import ServiceSmsSenderForm
@pytest.mark.parametrize(
"sms_sender,error_expected,error_message",
[
('', True, 'Cannot be empty'),
('22', True, 'Enter 3 characters or more'),
('333', False, None),
('elevenchars', False, None), # 11 chars
('twelvecharas', True, 'Enter 11 characters or fewer'), # 12 chars
('###', True, 'Use letters and numbers only'),
('00111222333', True, 'Cannot start with 00'),
('UK_GOV', False, None), # Underscores are allowed
('UK.GOV', False, None), # Full stops are allowed
("", True, "Cannot be empty"),
("22", True, "Enter 3 characters or more"),
("333", False, None),
("elevenchars", False, None), # 11 chars
("twelvecharas", True, "Enter 11 characters or fewer"), # 12 chars
("###", True, "Use letters and numbers only"),
("00111222333", True, "Cannot start with 00"),
("UK_GOV", False, None), # Underscores are allowed
("UK.GOV", False, None), # Full stops are allowed
("'UC'", False, None), # Straight single quotes are allowed
]
],
)
def test_sms_sender_form_validation(
client_request,
mock_get_user_by_email,
sms_sender,
error_expected,
error_message
client_request, mock_get_user_by_email, sms_sender, error_expected, error_message
):
form = ServiceSmsSenderForm()
form.sms_sender.data = sms_sender
@@ -32,6 +28,6 @@ def test_sms_sender_form_validation(
if error_expected:
assert form.errors
assert error_message == form.errors['sms_sender'][0]
assert error_message == form.errors["sms_sender"][0]
else:
assert not form.errors

32
tests/app/main/forms/test_strip_whitespace.py
View File

@@ -5,28 +5,34 @@ from app.main.forms import StripWhitespaceForm, StripWhitespaceStringField
class ExampleForm(StripWhitespaceForm):
foo = StringField('Foo')
foo = StringField("Foo")
class ExampleFormSpecialField(Form):
foo = StripWhitespaceStringField('foo')
foo = StripWhitespaceStringField("foo")
@pytest.mark.parametrize('submitted_data', [
'bar',
' bar ',
"""
@pytest.mark.parametrize(
"submitted_data",
[
"bar",
" bar ",
"""
\t bar
""",
' \u180E\u200B \u200C bar \u200D \u2060\uFEFF ',
])
@pytest.mark.parametrize('form', [
ExampleForm,
ExampleFormSpecialField,
])
" \u180E\u200B \u200C bar \u200D \u2060\uFEFF ",
],
)
@pytest.mark.parametrize(
"form",
[
ExampleForm,
ExampleFormSpecialField,
],
)
def test_form_strips_all_whitespace(
notify_admin,
form,
submitted_data,
):
assert form(foo=submitted_data).foo.data == 'bar'
assert form(foo=submitted_data).foo.data == "bar"

76
tests/app/main/forms/test_two_factor_form.py
View File

@@ -5,76 +5,82 @@ from app.main.forms import TwoFactorForm
def _check_code(code):
return user_api_client.check_verify_code('1', code, "sms")
return user_api_client.check_verify_code("1", code, "sms")
@pytest.mark.parametrize('post_data', [
{'sms_code': '123456'},
{'sms_code': ' 123456 '},
{'sms_code': '12 34 56'},
{'sms_code': '1-23-45-6'},
])
@pytest.mark.parametrize(
"post_data",
[
{"sms_code": "123456"},
{"sms_code": " 123456 "},
{"sms_code": "12 34 56"},
{"sms_code": "1-23-45-6"},
],
)
def test_form_is_valid_returns_no_errors(
notify_admin,
mock_check_verify_code,
post_data,
):
with notify_admin.test_request_context(method='POST', data=post_data):
with notify_admin.test_request_context(method="POST", data=post_data):
form = TwoFactorForm(_check_code)
assert form.validate() is True
assert form.errors == {}
mock_check_verify_code.assert_called_once_with('1', '123456', 'sms')
mock_check_verify_code.assert_called_once_with("1", "123456", "sms")
@pytest.mark.parametrize('post_data, expected_error', (
@pytest.mark.parametrize(
"post_data, expected_error",
(
{'sms_code': '1234'},
'Not enough numbers',
(
{"sms_code": "1234"},
"Not enough numbers",
),
(
{"sms_code": "1234567"},
"Too many numbers",
),
(
{},
"Cannot be empty",
),
(
{"sms_code": "12E456"},
"Numbers only",
),
(
{"sms_code": " ! 2 3 4 5 6"},
"Numbers only",
),
),
(
{'sms_code': '1234567'},
'Too many numbers',
),
(
{},
'Cannot be empty',
),
(
{'sms_code': '12E456'},
'Numbers only',
),
(
{'sms_code': ' ! 2 3 4 5 6'},
'Numbers only',
),
))
)
def test_check_verify_code_returns_errors(
notify_admin,
post_data,
expected_error,
mock_check_verify_code,
):
with notify_admin.test_request_context(method='POST', data=post_data):
with notify_admin.test_request_context(method="POST", data=post_data):
form = TwoFactorForm(_check_code)
assert form.validate() is False
assert form.errors == {'sms_code': [expected_error]}
assert form.errors == {"sms_code": [expected_error]}
def test_check_verify_code_returns_error_when_code_has_expired(
notify_admin,
mock_check_verify_code_code_expired,
):
with notify_admin.test_request_context(method='POST', data={'sms_code': '999999'}):
with notify_admin.test_request_context(method="POST", data={"sms_code": "999999"}):
form = TwoFactorForm(_check_code)
assert form.validate() is False
assert form.errors == {'sms_code': ['Code has expired']}
assert form.errors == {"sms_code": ["Code has expired"]}
def test_check_verify_code_returns_error_when_code_was_not_found(
notify_admin,
mock_check_verify_code_code_not_found,
):
with notify_admin.test_request_context(method='POST', data={'sms_code': '999999'}):
with notify_admin.test_request_context(method="POST", data={"sms_code": "999999"}):
form = TwoFactorForm(_check_code)
assert form.validate() is False
assert form.errors == {'sms_code': ['Code not found']}
assert form.errors == {"sms_code": ["Code not found"]}