def test_create_user_with_generated_username(mocker, valid_address_dict):
"""
Integration test to assert that create_user_with_generated_username tries to find an available
username and try again to save a User if there was a username collision
"""
username = "******"
# Create a user with the desired username before calling the function so we get a collision
UserFactory.create(username=username)
data = {
"username": username,
"email": "*****@*****.**",
"name": "Test User",
"legal_address": valid_address_dict,
"password": "******",
}
serializer = UserSerializer(data=data)
serializer.is_valid()
patched_find_username = mocker.patch(
"authentication.api.find_available_username", return_value="testuser1")
created_user = api.create_user_with_generated_username(
serializer, username)
patched_find_username.assert_called_once_with(username)
assert created_user is not None
assert created_user.username == patched_find_username.return_value
def test_find_available_username(
mocker, username_base, suffixed_to_create, expected_available_username
):
"""find_available_username should return an available username with the lowest possible suffix"""
# Change the username max length to 10 for test data simplicity's sake
temp_username_max_len = 10
mocker.patch("users.api.USERNAME_MAX_LEN", temp_username_max_len)
def suffixed_username_generator():
"""Generator for usernames with suffixes that will not exceed the username character limit"""
for suffix_int in range(1, suffixed_to_create + 1):
suffix = str(suffix_int)
username = "******".format(username_base, suffix)
if len(username) <= temp_username_max_len:
yield username
else:
num_extra_characters = len(username) - temp_username_max_len
yield "{}{}".format(
username_base[0 : len(username_base) - num_extra_characters], suffix
)
UserFactory.create(username=username_base)
UserFactory.create_batch(
suffixed_to_create, username=factory.Iterator(suffixed_username_generator())
)
available_username = find_available_username(username_base)
assert available_username == expected_available_username
def test_safe_format_recipients():
"""Test that we get a list of emailable recipients"""
user = UserFactory.create()
user_no_email = UserFactory.create(email="")
user_no_name = UserFactory.create(name="")
assert safe_format_recipients([user, user_no_email, user_no_name]) == [
(formataddr((user.name, user.email)), user),
(formataddr((None, user_no_name.email)), user_no_name),
]
def test_course_available_runs():
"""enrolled runs for a user should not be in the list of available runs"""
user = UserFactory.create()
course = CourseFactory.create()
runs = CourseRunFactory.create_batch(2, course=course, live=True)
runs.sort(key=lambda run: run.start_date)
CourseRunEnrollmentFactory.create(run=runs[0], user=user)
assert course.available_runs(user) == [runs[1]]
assert course.available_runs(UserFactory.create()) == runs
def test_website_endpoint_search(drf_client):
""" should limit the queryset based on the search param """
superuser = UserFactory.create(is_superuser=True)
drf_client.force_login(superuser)
WebsiteFactory.create(title="Apple", name="Bacon",
short_id="Cheese").save()
WebsiteFactory.create(title="Xylophone", name="Yellow",
short_id="Zebra").save()
WebsiteFactory.create(
title="U.S. Military Power",
name="17-482-u-s-military-power-spring-2015",
short_id="17.482-Spring-2015",
).save()
WebsiteFactory.create(
title="Biomedical Signal and Image Processing",
name="hst-582j-biomedical-signal-and-image-processing-spring-2007",
short_id="HST.582J-Spring-2007",
).save()
for word in ["Apple", "Bacon", "Cheese"]:
resp = drf_client.get(reverse("websites_api-list"), {"search": word})
assert [website["title"]
for website in resp.data.get("results")] == ["Apple"]
for word in ["Xylophone", "Yellow", "Zebra"]:
resp = drf_client.get(reverse("websites_api-list"), {"search": word})
assert [website["title"]
for website in resp.data.get("results")] == ["Xylophone"]
for word in ["U.S. military", "17-482", "17.482"]:
resp = drf_client.get(reverse("websites_api-list"), {"search": word})
assert [website["title"] for website in resp.data.get("results")
] == ["U.S. Military Power"]
for word in ["signal and image", "HsT.582", "hSt-582"]:
resp = drf_client.get(reverse("websites_api-list"), {"search": word})
assert [website["title"] for website in resp.data.get("results")
] == ["Biomedical Signal and Image Processing"]
def test_batch_delete_files(mocker, mock_api_wrapper, has_user):
"""Batch delete multiple git files in a single commit"""
user = UserFactory.create() if has_user else None
mock_element = mocker.patch("content_sync.apis.github.InputGitTreeElement")
mock_git_user = mocker.patch("content_sync.apis.github.InputGitAuthor")
paths = [
"content/testpages/page1.md",
"content/testresources/video1.md",
"content/testresources/video2.md",
]
mock_api_wrapper.batch_delete_files(paths, user=user)
tree_args = mock_api_wrapper.org.get_repo.return_value.create_git_tree.call_args[
0][0]
assert len(tree_args) == len(paths)
for path in paths:
mock_element.assert_any_call(
path,
"100644",
"blob",
sha=None,
)
mock_api_wrapper.org.get_repo.return_value.create_git_commit.assert_called_once_with(
"Sync all content",
mock_api_wrapper.org.get_repo.return_value.create_git_tree.
return_value,
mocker.ANY,
committer=mocker.ANY,
author=mocker.ANY,
)
if has_user:
mock_git_user.assert_called_once_with(user.name, user.email)
else:
mock_git_user.assert_called_once_with(settings.GIT_DEFAULT_USER_NAME,
settings.GIT_DEFAULT_USER_EMAIL)
def setUp(self):
self.user = UserFactory.create(email="*****@*****.**",
password="******")
self.application = Application(
name="Test Application",
redirect_uris="http://localhost",
user=self.user,
client_type=Application.CLIENT_CONFIDENTIAL,
authorization_grant_type=Application.GRANT_PASSWORD,
)
self.application.save()
self.token = AccessToken.objects.create(
user=self.user,
token="1234567890",
application=self.application,
expires=timezone.now() + datetime.timedelta(days=1),
scope="read write",
)
self.client.credentials(
HTTP_AUTHORIZATION="Bearer {}".format(self.token.token))
self.url_list = reverse("accounts-list")
self.accounts_data = AccountsFactory.create_batch(size=10)
self.return_fields = (
"url",
"slug",
"title",
"description",
"created",
"modified",
)
def test_order_status_customer_name(client):
"""
Test that the correct customer name is returned by order status API
"""
order = B2BOrderFactory.create()
resp = client.get(
reverse("b2b-order-status", kwargs={"hash": str(order.unique_id)}))
# Order status API returns no customer name if there is no existing user associated with order email and there is no
# receipt associated with order
assert resp.status_code == status.HTTP_200_OK
assert resp.json().get("customer_name") == ""
receipt_date = {
"req_bill_to_forename": "Test",
"req_bill_to_surname": "Name"
}
# Order status API returns customer name from the receipt data when there is no user account with order email
B2BReceipt.objects.create(order=order, data=receipt_date)
resp = client.get(
reverse("b2b-order-status", kwargs={"hash": str(order.unique_id)}))
assert resp.status_code == status.HTTP_200_OK
assert resp.json().get("customer_name") == "Test Name"
# Order status API returns name of the existing user if there exists an order's email matching user account
test_user = UserFactory.create(email=order.email)
resp = client.get(
reverse("b2b-order-status", kwargs={"hash": str(order.unique_id)}))
assert resp.status_code == status.HTTP_200_OK
assert resp.json().get("customer_name") == test_user.name
def test_update_user_email(mocker, user, raises_error): # pylint: disable=too-many-arguments
"""Test that update edx user email takes the correct action"""
mock_update_edx_user_email = mocker.patch(
"courseware.tasks.api.update_edx_user_email")
new_user = UserFactory.create()
if raises_error:
mock_update_edx_user_email.side_effect = Exception("error")
new_email = new_user.email
else:
new_email = "*****@*****.**"
mock_change_edx_user_email_task = mocker.patch(
"courseware.tasks.change_edx_user_email_async")
change_request = ChangeEmailRequest.objects.create(user=user,
new_email=new_email)
serializer = ChangeEmailRequestUpdateSerializer(change_request,
{"confirmed": True})
try:
serializer.is_valid()
serializer.save()
except ValidationError:
pass
if raises_error:
mock_update_edx_user_email.assert_not_called()
else:
mock_update_edx_user_email.assert_called_once_with(user)
mock_change_edx_user_email_task.apply_async.assert_not_called()
def test_fetch_user(prop, value, db_value):
"""
fetch_user should return a User that matches a provided value which represents
an id, email, or username
"""
user = UserFactory.create(**{prop: db_value or value})
found_user = fetch_user(value)
assert user == found_user
def test_post_ok(self):
payload = DriverGroupFactory.attributes()
payload["drivers"] = [DriverFactory.create().id]
payload["author"] = UserFactory.create().id
response = self.client.post(reverse("api:drivergroup-list"),
data=payload,
format="json")
self.assert_post_ok(response)
def test_full_username_creation():
"""
Integration test to ensure that the USERNAME_MAX_LEN constant is set correctly, and that
generated usernames do not exceed it.
"""
expected_username_max = 30
user_full_name = "Longerton McLongernamenbergenstein"
generated_username = usernameify(user_full_name)
assert len(generated_username) == expected_username_max
UserFactory.create(username=generated_username, name=user_full_name)
new_user_full_name = "{} Jr.".format(user_full_name)
new_generated_username = usernameify(new_user_full_name)
assert new_generated_username == generated_username
available_username = find_available_username(new_generated_username)
assert available_username == "{}1".format(
new_generated_username[0 : expected_username_max - 1]
)
def test_fetch_user_case_sens():
"""fetch_user should be able to fetch a User with a case-insensitive filter"""
email = "*****@*****.**"
user = UserFactory.create(email=email)
upper_email = email.upper()
with pytest.raises(User.DoesNotExist):
fetch_user(upper_email, ignore_case=False)
assert fetch_user(upper_email, ignore_case=True) == user
def test_websites_endpoint_detail_methods_denied(drf_client, method, status):
"""Certain request methods should always be denied"""
website = WebsiteFactory.create()
drf_client.force_login(UserFactory.create(is_superuser=True))
client_func = getattr(drf_client, method)
resp = client_func(
reverse("websites_api-detail", kwargs={"name": website.name}))
assert resp.status_code == status
def setUp(self):
self.dsr_admin = UserFactory.create(group=DsrGroupFactory.create(
slug_field=settings.DSR_ADMIN_SLUG_FIELD,
linked_group__name=settings.DSR_ADMIN_GROUP_NAME,
custom_user_permissions=[settings.CAN_ADD_DSR_EMPLOYEE_NAME],
))
self.dsr_employee = UserFactory.create(group=DsrGroupFactory.create(
slug_field=settings.DSR_EMPLOYEE_SLUG_FIELD,
linked_group__name=settings.DSR_EMPLOYEE_GROUP_NAME,
custom_user_permissions=[
# Add User Permissions
],
))
self.dsr_customer_super_admin = UserFactory.create(
group=DsrGroupFactory.create(
slug_field=settings.DSR_CUSTOMER_SUPER_ADMIN_SLUG_FIELD,
linked_group__name=settings.
DSR_CUSTOMER_SUPER_ADMIN_GROUP_NAME,
custom_user_permissions=[
# Add User Permissions
settings.CAN_ADD_DSR_CUSTOMER_ADMIN_NAME,
settings.CAN_ADD_DSR_CUSTOMER_USER_NAME
],
))
self.dsr_customer_admin = UserFactory.create(
group=DsrGroupFactory.create(
slug_field=settings.DSR_CUSTOMER_ADMIN_SLUG_FIELD,
linked_group__name=settings.DSR_CUSTOMER_ADMIN_GROUP_NAME,
custom_user_permissions=[
# Add User Permissions
settings.CAN_ADD_DSR_CUSTOMER_USER_NAME
],
))
self.dsr_customer_user = UserFactory.create(
group=DsrGroupFactory.create(
slug_field=settings.DSR_CUSTOMER_USER_SLUG_FIELD,
linked_group__name=settings.DSR_CUSTOMER_USER_GROUP_NAME,
custom_user_permissions=[
# Add User Permissions
],
))
def handle(self, *args, **kwargs):
UserFactory.create(email="*****@*****.**",
is_staff=True,
is_superuser=True)
dealers = []
for dealer in [("Parts Express", "https://www.parts-express.com")]:
dealers.append(
DealerFactory.create(name=dealer[0], website=dealer[1]))
self.stdout.write("Created {0} Dealer(s)".format(len(dealers)))
dealer_scrapers = []
for dealer in dealers:
dealer_scrapers.append(
DealerScraperFactory.create(class_name="PartsExpressScraper",
dealer=dealer))
self.stdout.write("Created {0} DealerScraper(s)".format(
len(dealer_scrapers)))
def test_website_collaborator_serializer():
""" WebsiteCollaboratorSerializer should serialize a User object with correct fields """
collaborator = (User.objects.filter(id=UserFactory.create().id).annotate(
role=Value(ROLE_EDITOR, CharField())).first())
serialized_data = WebsiteCollaboratorSerializer(instance=collaborator).data
assert serialized_data["user_id"] == collaborator.id
assert serialized_data["name"] == collaborator.name
assert serialized_data["email"] == collaborator.email
assert serialized_data["role"] == ROLE_EDITOR
def test_websites_endpoint_detail_get_denied(drf_client):
"""Anonymous user or user without permissions should not be able to view the site"""
for user in (None, UserFactory.create()):
if user:
drf_client.force_login(user)
website = WebsiteFactory.create()
resp = drf_client.get(
reverse("websites_api-detail", kwargs={"name": website.name}))
assert resp.status_code == 403 if not user else 404
def test_multiple_success_blocking_user(self):
"""test block_users command blocking emails success with more than one user"""
test_usernames = ["*****@*****.**", "*****@*****.**", "*****@*****.**"]
for username in test_usernames:
user = UserFactory.create(username=username, is_active=True)
assert BlockList.objects.all().count() == 0
COMMAND.handle("block_users", users=test_usernames, block_users=True)
assert BlockList.objects.all().count() == 3
def test_websites_endpoint_list_forbidden_methods(drf_client, method):
"""No put, patch, or delete requests allowed at this endpoint"""
drf_client.force_login(UserFactory.create(is_superuser=True))
client_func = getattr(drf_client, method)
resp = client_func(reverse("websites_api-list"),
data={
"name": "fakename",
"title": "Fake Title"
})
assert resp.status_code == 405
def test_is_global_admin(permission_groups):
""" Global admin users should be identified correctly """
superuser = UserFactory.create(is_superuser=True)
for user in [permission_groups.global_admin, superuser]:
assert permissions.is_global_admin(user) is True
for user in [
permission_groups.global_author,
permission_groups.site_admin,
permission_groups.site_editor,
]:
assert permissions.is_global_admin(user) is False
def test_update_email_change_request_existing_email(user):
"""Test that update change email request gives validation error for existing user email"""
new_user = UserFactory.create()
change_request = ChangeEmailRequest.objects.create(
user=user, new_email=new_user.email)
serializer = ChangeEmailRequestUpdateSerializer(change_request,
{"confirmed": True})
with pytest.raises(ValidationError):
serializer.is_valid()
serializer.save()
def setUpClass(cls):
super().setUpClass()
cls.user = UserFactory.create()
cls.user.save()
# needed to get names of HVCs, have to do again because factory
# remembers other tests, even if flushed from DB
for i in range(255):
HVCFactory.create(
campaign_id='E%03d' % (i + 1),
financial_year=16,
)
def test_website_endpoint_empty_search(drf_client):
""" should limit the queryset based on the search param """
superuser = UserFactory.create(is_superuser=True)
drf_client.force_login(superuser)
WebsiteFactory.create()
WebsiteFactory.create()
WebsiteFactory.create()
resp = drf_client.get(reverse("websites_api-list"), {"search": ""})
expected_uuids = sorted(
[site.uuid.__str__() for site in Website.objects.all()])
assert expected_uuids == sorted(
[site["uuid"] for site in resp.data["results"]])
def test_admin_new_password(self):
self._make_staff()
self._login()
UserFactory.create(email='*****@*****.**')
response = self.alice_client.post(
reverse('admin-new-password'),
{'email': '*****@*****.**'},
)
self.assertEqual(response.status_code, 201)
self.assertEquals(len(mail.outbox), 1)
self.assertEquals(
mail.outbox[0].subject,
'Export Wins Login Credentials',
)
self.assertIn(
'This email contains your login credentials',
mail.outbox[0].body,
)
self.assertEqual(
mail.outbox[0].to[0],
'*****@*****.**',
)
def setUp(self):
self.client = Client()
self.alice_client = AliceClient()
self.user = UserFactory.create()
self.user.set_password('asdf')
self.user.save()
self.superuser = UserFactory.create(is_superuser=True, email="[email protected]")
self.wins_schema = reverse("drf:win-schema")
self.wins_list = reverse("drf:win-list")
self.wins_detail = reverse("drf:win-detail", kwargs={
"pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
})
self.customerresponses_schema = reverse("drf:customerresponse-schema")
self.customerresponses_list = reverse("drf:customerresponse-list")
self.customerresponses_detail = reverse("drf:customerresponse-detail", kwargs={
"pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
})
self.breakdowns_schema = reverse("drf:breakdown-schema")
self.breakdowns_list = reverse("drf:breakdown-list")
self.breakdowns_detail = reverse("drf:breakdown-detail", kwargs={
"pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
})
self.advisors_schema = reverse("drf:advisor-schema")
self.advisors_list = reverse("drf:advisor-list")
self.advisors_detail = reverse("drf:advisor-detail", kwargs={
"pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
})
self.win = WinFactory.create()
self.WINS_POST_SAMPLE = {
"user": self.user.id,
"cdms_reference": "cdms reference",
"company_name": "company name",
"country": "AF",
"created": "2016-05-17T12:44:48.021705Z",
"customer_email_address": "*****@*****.**",
"customer_job_title": "customer job title",
"customer_location": 3,
"customer_name": "customer name",
"date": "1979-06-01",
"description": "asdlkjskdlfkjlsdjkl",
"goods_vs_services": 1,
"has_hvo_specialist_involvement": True,
"hq_team": "other:1",
"hvo_programme": "BSC-01",
"is_e_exported": True,
"is_line_manager_confirmed": True,
"is_personally_confirmed": True,
"is_prosperity_fund_related": True,
"lead_officer_name": "lead officer name",
"line_manager_name": "line manager name",
"location": "Edinburgh, UK",
"sector": 1,
"team_type": "investment",
"total_expected_export_value": 5,
"total_expected_non_export_value": 5,
"total_expected_odi_value": 5,
"type": 1,
"type_of_support_1": 1,
"business_type": 1,
"name_of_export": "name",
"name_of_customer": "name",
}
self.CUSTOMER_RESPONSES_POST_SAMPLE = {
"win": str(self.win.pk),
"name": "bob",
"improved_profile": "1",
"gained_confidence": "1",
"access_to_information": "1",
"expected_portion_without_help": "1",
"last_export": "1",
"overcame_problem": "1",
"developed_relationships": "1",
"access_to_contacts": "1",
"our_support": "1",
"marketing_source": "1",
"other_marketing_source": ""
}
self.BREAKDOWNS_POST_SAMPLE = {
"win": str(self.win.pk),
"type": Breakdown.TYPE_EXPORT,
"year": "1999",
"value": "1",
}
self.ADVISORS_POST_SAMPLE = {
"win": str(self.win.pk),
"name": "bob",
"team_type": "other",
"hq_team": "team:1",
"location": "france"
}
