def setUp(self):
super(TestMigrateProfileWebsites, self).setUp()
self.user_one = UserFactory.build(
fullname="Martin Luther King",
social=dict(
github="userOneGithub",
scholar="userOneScholar",
personal="http://www.useronewebsite.com",
twitter="userOneTwitter",
linkedIn="userOneLinkedIn",
impactStory="userOneImpactStory",
orcid="userOneOrcid",
researcherId="userOneResearcherId",
),
)
self.user_one.save()
self.user_two = UserFactory.build(
fullname="el-Hajj Malik el-Shabazz",
social=dict(
github="userTwoGithub",
scholar="userTwoScholar",
profileWebsites=["http://www.usertwowebsite.com"],
twitter="userTwoTwitter",
linkedIn="userTwoLinkedIn",
impactStory="userTwoImpactStory",
orcid="userTwoOrcid",
researcherId="userTwoResearcherId",
),
)
self.user_two.save()
self.user_three = UserFactory()
def setUp(self):
super(TestUserNodes, self).setUp()
self.user_one = UserFactory.build()
self.user_one.set_password('justapoorboy')
self.user_one.social['twitter'] = 'howtopizza'
self.user_one.save()
self.auth_one = (self.user_one.username, 'justapoorboy')
self.user_two = UserFactory.build()
self.user_two.set_password('justapoorboy')
self.user_two.save()
self.auth_two = (self.user_two.username, 'justapoorboy')
self.public_project_user_one = ProjectFactory(title="Public Project User One",
is_public=True,
creator=self.user_one)
self.private_project_user_one = ProjectFactory(title="Private Project User One",
is_public=False,
creator=self.user_one)
self.public_project_user_two = ProjectFactory(title="Public Project User Two",
is_public=True,
creator=self.user_two)
self.private_project_user_two = ProjectFactory(title="Private Project User Two",
is_public=False,
creator=self.user_two)
self.deleted_project_user_one = FolderFactory(title="Deleted Project User One",
is_public=False,
creator=self.user_one,
is_deleted=True)
self.folder = FolderFactory()
self.deleted_folder = FolderFactory(title="Deleted Folder User One",
is_public=False,
creator=self.user_one,
is_deleted=True)
self.dashboard = DashboardFactory()
def setUp(self):
super(TestMigrateProfileWebsites, self).setUp()
self.user_one = UserFactory.build(
fullname='Martin Luther King',
social=dict(
github='userOneGithub',
scholar='userOneScholar',
personal='http://www.useronewebsite.com',
twitter='userOneTwitter',
linkedIn='userOneLinkedIn',
impactStory='userOneImpactStory',
orcid='userOneOrcid',
researcherId='userOneResearcherId',
),
)
self.user_one.save()
self.user_two = UserFactory.build(
fullname='el-Hajj Malik el-Shabazz',
social=dict(github='userTwoGithub',
scholar='userTwoScholar',
profileWebsites=['http://www.usertwowebsite.com'],
twitter='userTwoTwitter',
linkedIn='userTwoLinkedIn',
impactStory='userTwoImpactStory',
orcid='userTwoOrcid',
researcherId='userTwoResearcherId'))
self.user_two.save()
self.user_three = UserFactory()
def test_size_of_creators_completed_uploads():
def upload_files_for_user(user, n=1):
for _ in range(n):
ul = UserUpload(creator=user)
ul.create_multipart_upload()
presigned_urls = ul.generate_presigned_urls(part_numbers=[1])
response = put(presigned_urls["1"], data=b"123")
ul.complete_multipart_upload(
parts=[{
"ETag": response.headers["ETag"],
"PartNumber": 1
}])
u = UserFactory.build(pk=42)
upload = UserUpload(creator=u)
upload.LIST_MAX_ITEMS = 1
initial_upload_size = upload.size_of_creators_completed_uploads
assert type(initial_upload_size) == int
upload_files_for_user(user=u, n=upload.LIST_MAX_ITEMS + 1)
# another users files should not be considered
upload_files_for_user(user=UserFactory.build(pk=u.pk + 1))
assert (upload.size_of_creators_completed_uploads == initial_upload_size +
(upload.LIST_MAX_ITEMS + 1) * 3)
def test_active_inactive(session, strict, app, client):
"""
The first user to register should be an activated admin, and subsequent
users should be inactive and regular users.
"""
app.config["USER_REGISTRATION_APPROVAL"] = strict
# Non-admins aren't allowed to specify these fields
dump_only = dump_only_fields(UserSchema) + [
"admin", "active", "salt", "api_token"
]
req_schema = UserSchema(many=False, use_links=False, exclude=dump_only)
res_schema = UserSchema(many=False, unknown=EXCLUDE)
url = url_for("rest_api.userlist")
first = UserFactory.build()
second = UserFactory.build()
# The first created user should be an active admin
first_res: Flask.response_class = client.post(path=url,
json=req_schema.dump(first))
raise_response(first_res)
first_model: dict = res_schema.load(first_res.json)
assert first_model["active"]
assert first_model["is_admin"]
# The second and subsequent users should be active only if it's not in strict mode
second_res: Flask.response_class = client.post(
path=url, json=req_schema.dump(second))
raise_response(second_res)
second_model: dict = res_schema.load(second_res.json)
assert second_model["active"] != strict
assert not second_model["is_admin"]
def setUp(self):
super(TestMergingAccounts, self).setUp()
self.user = UserFactory.build()
self.user.set_password('science')
self.user.save()
self.dupe = UserFactory.build()
self.dupe.set_password('example')
self.dupe.save()
def setUp(self):
super(TestMergingAccounts, self).setUp()
self.user = UserFactory.build()
self.user.set_password('science')
self.user.save()
self.dupe = UserFactory.build()
self.dupe.set_password('example')
self.dupe.save()
def setUp(self):
super(TestMergingAccounts, self).setUp()
self.user = UserFactory.build()
self.user.fullname = "tess' test string"
self.user.set_password("science")
self.user.save()
self.dupe = UserFactory.build()
self.dupe.set_password("example")
self.dupe.save()
def setUp(self):
ApiTestCase.setUp(self)
self.user_one = UserFactory.build()
self.user_one.set_password('justapoorboy')
self.user_one.social['twitter'] = 'howtopizza'
self.user_one.save()
self.auth_one = (self.user_one.username, 'justapoorboy')
self.user_two = UserFactory.build()
self.user_two.set_password('justapoorboy')
self.user_two.save()
self.auth_two = (self.user_two.username, 'justapoorboy')
def setUp(self):
ApiTestCase.setUp(self)
self.user_one = UserFactory.build()
self.user_one.set_password('justapoorboy')
self.user_one.social['twitter'] = 'howtopizza'
self.user_one.save()
self.auth_one = (self.user_one.username, 'justapoorboy')
self.user_two = UserFactory.build()
self.user_two.set_password('justapoorboy')
self.user_two.save()
self.auth_two = (self.user_two.username, 'justapoorboy')
def test_get_targets(self):
user1 = UserFactory.build(username='******')
user2 = UserFactory()
user1.save()
user_list = get_targets()
assert user_list is not None
assert len(user_list) is 1
user3 = UserFactory.build(username='******')
user3.save()
user_list = get_targets()
assert len(user_list) is 2
def test_get_targets(self):
user1 = UserFactory.build(username='******')
user2 = UserFactory()
user1.save()
user_list = get_targets()
assert user_list is not None
assert len(user_list) is 1
user3 = UserFactory.build(username='******')
user3.save()
user_list = get_targets()
assert len(user_list) is 2
def test_do_migration(self):
today = timezone.now()
user1 = UserFactory.build(date_confirmed=None, date_last_login=today, is_registered=False)
user2 = UserFactory.build(date_confirmed=None, date_last_login=today, is_registered=True)
user1.save()
user2.save()
user_list = User.find(Q('_id', 'eq', user1._id) | Q('_id', 'eq', user2._id))
do_migration(user_list)
assert user1.date_confirmed is today
assert user1.is_registered
assert user2.date_confirmed is today
assert user2.is_registered
def test_get_targets(self):
today = timezone.now()
user1 = UserFactory.build(date_confirmed=today, date_last_login=today)
user2 = UserFactory.build(date_confirmed=None, date_last_login=today)
user1.save()
user2.save()
user_list = get_targets()
assert user_list is not None
assert len(user_list) is 1
user1.date_confirmed = None
user1.save()
user_list = get_targets()
assert len(user_list) is 2
def test_get_targets(self):
today = timezone.now()
user1 = UserFactory.build(date_confirmed=today, date_last_login=today)
user2 = UserFactory.build(date_confirmed=None, date_last_login=today)
user1.save()
user2.save()
user_list = get_targets()
assert user_list is not None
assert len(user_list) is 1
user1.date_confirmed = None
user1.save()
user_list = get_targets()
assert len(user_list) is 2
def generate_external_user_with_resp(user=True, release=True):
"""
Generate mock user, external credential and cas response for tests.
:param user: set to `False` if user does not exists
:param release: set to `False` if attributes are not released due to privacy settings
:return: existing user object or new user, valid external credential, valid cas response
"""
cas_resp = make_external_response(release=release)
validated_credentials = cas.validate_external_credential(cas_resp.user)
if user:
user = UserFactory.build()
user.external_identity = {
validated_credentials['provider']: {
validated_credentials['id']: 'VERIFIED'
}
}
user.save()
return user, validated_credentials, cas_resp
else:
user = {
'external_id_provider': validated_credentials['provider'],
'external_id': validated_credentials['id'],
'fullname': validated_credentials['id'],
'access_token': cas_resp.attributes['accessToken'],
}
return user, validated_credentials, cas_resp
def test_do_migration(self):
user1 = UserFactory()
fullname1 = 'Presentation Service'
email1 = '*****@*****.**'
project1 = ProjectFactory(creator=user1)
user2 = project1.add_unregistered_contributor(fullname=fullname1,
email=email1,
auth=Auth(user=user1))
project1.save()
user3 = UserFactory.build(username='******',
fullname=fullname1)
user3.save()
project2 = ProjectFactory(creator=user1)
project2.add_contributor(user3)
project2.save()
assert project1.is_contributor(user2) is True
assert len(project1.contributors) is 2
assert project2.is_contributor(user3) is True
assert len(project2.contributors) is 2
user_list = get_targets()
do_migration(user_list)
assert project2.is_contributor(user3) is False
assert len(project2.contributors) is 1
assert project1.is_contributor(user2) is False
assert len(project1.contributors) is 1
assert user2.is_disabled is True
assert user3.is_disabled is True
def test_do_migration(self):
user1 = UserFactory()
fullname1 = 'Presentation Service'
email1 = '*****@*****.**'
project1 = ProjectFactory(creator=user1)
user2 = project1.add_unregistered_contributor(
fullname=fullname1, email=email1, auth=Auth(user=user1)
)
project1.save()
user3 = UserFactory.build(username='******', fullname=fullname1)
user3.save()
project2 = ProjectFactory(creator=user1)
project2.add_contributor(user3)
project2.save()
assert project1.is_contributor(user2) is True
assert len(project1.contributors) is 2
assert project2.is_contributor(user3) is True
assert len(project2.contributors) is 2
user_list = get_targets()
do_migration(user_list)
assert project2.is_contributor(user3) is False
assert len(project2.contributors) is 1
assert project1.is_contributor(user2) is False
assert len(project1.contributors) is 1
assert user2.is_disabled is True
assert user3.is_disabled is True
def test_get_targets(self):
user1 = UserFactory.build(merged_by=None)
user2 = UserFactory.build(merged_by=user1)
user3 = UserFactory.build()
user1.save()
user2.save()
user3.save()
user_list = get_targets()
assert user_list is not None
assert len(user_list) is 1
user1.merged_by = user3
user1.save()
user_list = get_targets()
assert len(user_list) is 2
def user_client(django_user_model):
"""
User fixture for tests with unprivileged user
"""
example_user = UserFactory.build()
created_user = django_user_model.objects.create_user(example_user)
return created_user
def generate_external_user_with_resp(service_url, user=True, release=True):
"""
Generate mock user, external credential and cas response for tests.
:param service_url: the service url
:param user: set to `False` if user does not exists
:param release: set to `False` if attributes are not released due to privacy settings
:return: existing user object or new user, valid external credential, valid cas response
"""
cas_resp = make_external_response(release=release)
validated_credentials = cas.validate_external_credential(cas_resp.user)
if user:
user = UserFactory.build()
user.external_identity = {
validated_credentials['provider']: {
validated_credentials['id']: 'VERIFIED'
}
}
user.save()
return user, validated_credentials, cas_resp
else:
user = {
'external_id_provider': validated_credentials['provider'],
'external_id': validated_credentials['id'],
'fullname': validated_credentials['id'],
'access_token': cas_resp.attributes['accessToken'],
'service_url': service_url,
}
return user, validated_credentials, cas_resp
def test_get_targets(self):
user1 = UserFactory.build(merged_by=None)
user2 = UserFactory.build(merged_by=user1)
user3 = UserFactory.build()
user1.save()
user2.save()
user3.save()
user_list = get_targets()
assert user_list is not None
assert len(user_list) is 1
user1.merged_by = user3
user1.save()
user_list = get_targets()
assert len(user_list) is 2
def test_list_parts_empty():
upload = UserUpload(creator=UserFactory.build())
upload.create_multipart_upload()
parts = upload.list_parts()
assert parts == []
def test_invoice_repr(month):
user = UserFactory.build()
format_month = get_previous_month() if month is None else month
assert repr(Invoice(user, FAKE_CONFIG,
month=month)) == u"<Invoice %s:%s>" % (
user.username,
format_month.strftime(MONTH_FORMAT),
)
def test_get_targets(self):
user = UserFactory.build()
user.add_unclaimed_record(self.project, self.referrer, 'foo')
user.save()
assert_true(user.is_confirmed)
targets = list(get_targets())
assert_in(user, targets)
def test_it_creates_a_user(self, database):
user = UserFactory.build()
user_repository.create(user)
created_user = database.query(User).get(user.id)
assert created_user.username == user.username
def test_get_targets(self):
user = UserFactory.build()
user.add_unclaimed_record(self.project, self.referrer, 'foo')
user.save()
assert_true(user.is_confirmed)
targets = list(get_targets())
assert_in(user, targets)
def test_login_success_authenticates_user(self):
user = UserFactory.build(date_last_login=datetime.datetime.utcnow())
user.set_password('killerqueen')
user.save()
# need request context because login returns a rsponse
res = auth.login(user.username, 'killerqueen')
assert_true(isinstance(res, BaseResponse))
assert_equal(res.status_code, 302)
def test_login_success_authenticates_user(self):
user = UserFactory.build(date_last_login=datetime.datetime.utcnow())
user.set_password('killerqueen')
user.save()
# need request context because login returns a rsponse
res = auth.login(user.username, 'killerqueen')
assert_true(isinstance(res, BaseResponse))
assert_equal(res.status_code, 302)
def test_do_migration(self):
user = UserFactory.build()
user.add_unclaimed_record(self.project, self.referrer, 'foo')
user.save()
assert_true(user.is_confirmed)
assert_equal(len(user.unclaimed_records.keys()), 1)
do_migration()
assert_equal(len(user.unclaimed_records.keys()), 0)
def test_get_user_with_wrong_password_returns_false(self):
user = UserFactory.build()
user.set_password('killerqueen')
assert_false(
auth.get_user(
username=user.username,
password='******'
)
)
def test_do_migration(self):
user = UserFactory.build()
user.add_unclaimed_record(self.project, self.referrer, 'foo')
user.save()
assert_true(user.is_confirmed)
assert_equal(len(user.unclaimed_records.keys()), 1)
do_migration()
assert_equal(len(user.unclaimed_records.keys()), 0)
def test_do_migration(self):
today = dt.datetime.utcnow()
user1 = UserFactory.build(date_confirmed=None,
date_last_login=today,
is_registered=False)
user2 = UserFactory.build(date_confirmed=None,
date_last_login=today,
is_registered=True)
user1.save()
user2.save()
user_list = User.find(
Q('_id', 'eq', user1._id) | Q('_id', 'eq', user2._id))
do_migration(user_list)
assert user1.date_confirmed is today
assert user1.is_registered
assert user2.date_confirmed is today
assert user2.is_registered
def test_abort_multipart_upload():
upload = UserUpload(creator=UserFactory.build())
upload.create_multipart_upload()
assert upload.status == UserUpload.StatusChoices.INITIALIZED
assert upload.s3_upload_id != ""
upload.abort_multipart_upload()
assert upload.status == UserUpload.StatusChoices.ABORTED
assert upload.s3_upload_id == ""
def test_get_user_by_external_info(self):
user = UserFactory.build()
validated_creds = cas.validate_external_credential(make_external_response().user)
user.external_identity = {
validated_creds['provider']: {
validated_creds['id']: 'VERIFIED'
}
}
user.save()
assert_equal(auth.get_user(external_id_provider=validated_creds['provider'], external_id=validated_creds['id']), user)
def test_create_multipart_upload():
user = UserFactory.build()
upload = UserUpload(creator=user)
assert upload.s3_upload_id == ""
assert upload.status == UserUpload.StatusChoices.PENDING
upload.create_multipart_upload()
assert upload.s3_upload_id != ""
assert upload.status == UserUpload.StatusChoices.INITIALIZED
assert upload.key == f"uploads/{user.pk}/{upload.pk}"
def test_invoice_get_amounts(member):
"""Tests accessing amounts when they haven't been calculated yet.
"""
user = UserFactory.build()
invoice = Invoice(user, FAKE_CONFIG)
with pytest.raises(AssertionError):
invoice.amounts
invoice.generate()
assert invoice.amounts is not None
def test_list_parts():
upload = UserUpload(creator=UserFactory.build())
upload.create_multipart_upload()
url = upload.generate_presigned_url(part_number=1)
response = put(url, data=b"123")
parts = upload.list_parts()
assert len(parts) == 1
assert parts[0]["ETag"] == response.headers["ETag"]
assert parts[0]["Size"] == 3
assert parts[0]["PartNumber"] == 1
def test_password_change_sends_email(self, mock_mail):
user = UserFactory.build()
user.set_password('killerqueen')
assert_equal(len(mock_mail.call_args_list), 1)
empty, kwargs = mock_mail.call_args
kwargs['user'].reload()
assert_equal(empty, ())
assert_equal(kwargs, {
'user': user,
'mimetype': 'plain',
'mail': mails.PASSWORD_RESET,
'to_addr': user.username,
})
def test_size_incomplete():
u = UserFactory.build(pk=42)
upload = UserUpload(creator=u)
upload.create_multipart_upload()
upload.LIST_MAX_ITEMS = 1
assert upload.size == 0
parts = [1, 2]
presigned_urls = upload.generate_presigned_urls(part_numbers=parts)
for part in parts:
put(presigned_urls[str(part)], data=b"123")
assert upload.size == (upload.LIST_MAX_ITEMS + 1) * 3
def test_password_change_sends_email(self, mock_mail):
user = UserFactory.build()
user.set_password('killerqueen')
assert_equal(len(mock_mail.call_args_list), 1)
empty, kwargs = mock_mail.call_args
kwargs['user'].reload()
assert_equal(empty, ())
assert_equal(kwargs, {
'user': user,
'mimetype': 'plain',
'mail': mails.PASSWORD_RESET,
'to_addr': user.username,
})
def test_challenge_request_type_2_fields_required():
user = UserFactory.build()
# fill all fields except for budget and input / output fields
# for type 1 this form is valid
data = {
"creator": user,
"title": "Test request",
"short_name": "example1234",
"challenge_type": ChallengeRequest.ChallengeTypeChoices.T1,
"start_date": datetime.date.today(),
"end_date": datetime.date.today() + datetime.timedelta(days=1),
"expected_number_of_participants": 10,
"abstract": "test",
"contact_email": "*****@*****.**",
"organizers": "test",
"challenge_setup": "test",
"data_set": "test",
"submission_assessment": "test",
"challenge_publication": "test",
"code_availability": "test",
"expected_number_of_teams": 10,
"number_of_tasks": 1,
}
form = ChallengeRequestForm(data=data, creator=user)
assert form.is_valid()
# for type 2, these fields need to be filled
data2 = {
"creator": user,
"title": "Test request",
"short_name": "example1234",
"challenge_type": ChallengeRequest.ChallengeTypeChoices.T2,
"start_date": datetime.date.today(),
"end_date": datetime.date.today() + datetime.timedelta(days=1),
"expected_number_of_participants": 10,
"abstract": "test",
"contact_email": "*****@*****.**",
"organizers": "test",
"challenge_setup": "test",
"data_set": "test",
"submission_assessment": "test",
"challenge_publication": "test",
"code_availability": "test",
"expected_number_of_teams": 10,
"number_of_tasks": 1,
}
form2 = ChallengeRequestForm(data=data2, creator=user)
assert not form2.is_valid()
assert "For a type 2 challenge, you need to provide" in str(form2.errors)
def test_do_migration(self):
user1 = UserFactory.build(merged_by=None)
user2 = UserFactory.build(merged_by=user1, verification_key="key1")
user3 = UserFactory.build(merged_by=user1, verification_key="key2")
user2.email_verifications['token'] = {'email': '*****@*****.**'}
user3.email_verifications['token'] = {'email': '*****@*****.**'}
user1.save()
user2.save()
user3.save()
user_list = get_targets()
do_migration(user_list)
user2.reload()
user3.reload()
assert user2.username is None
assert user2.password is None
assert len(user2.email_verifications) is 0
assert user2.verification_key is None
assert user3.username is None
assert user3.password is None
assert len(user3.email_verifications) is 0
assert user3.verification_key is None
def test_do_migration(self):
user1 = UserFactory.build(merged_by=None)
user2 = UserFactory.build(merged_by=user1, verification_key="key1")
user3 = UserFactory.build(merged_by=user1, verification_key="key2")
user2.email_verifications['token'] = {'email': '*****@*****.**'}
user3.email_verifications['token'] = {'email': '*****@*****.**'}
user1.save()
user2.save()
user3.save()
user_list = get_targets()
do_migration(user_list)
user2.reload()
user3.reload()
assert user2.username is None
assert user2.password is None
assert len(user2.email_verifications) is 0
assert user2.verification_key is None
assert user3.username is None
assert user3.password is None
assert len(user3.email_verifications) is 0
assert user3.verification_key is None
def test_size_complete():
u = UserFactory.build(pk=42)
upload = UserUpload(creator=u)
upload.create_multipart_upload()
assert upload.size == 0
presigned_urls = upload.generate_presigned_urls(part_numbers=[1])
response = put(presigned_urls["1"], data=b"123")
upload.complete_multipart_upload(parts=[{
"ETag": response.headers["ETag"],
"PartNumber": 1
}])
assert upload.size == 3
def create_fake_user():
email = fake.email()
name = fake.name()
parsed = utils.impute_names(name)
user = UserFactory.build(username=email, fullname=name,
is_registered=True, is_claimed=True,
verification_key=security.random_string(15),
date_registered=fake.date_time(),
emails=[email],
**parsed
)
user.set_password('faker123')
user.save()
logger.info('Created user: {0} <{1}>'.format(user.fullname, user.username))
return user
def create_fake_user():
email = fake.email()
name = fake.name()
parsed = utils.impute_names(name)
user = UserFactory.build(username=email,
fullname=name,
is_registered=True,
is_claimed=True,
verification_key=security.random_string(15),
date_registered=fake.date_time(),
emails=[email],
**parsed)
user.set_password('faker123')
user.save()
logger.info('Created user: {0} <{1}>'.format(user.fullname, user.username))
return user
def generate_external_user_with_resp(user=True, release=True):
"""
Generate mock user, external credential and cas response for tests.
:param user: set to `False` if user does not exists
:param release: set to `False` if attributes are not released due to privacy settings
:return: existing user object or new user, valid external credential, valid cas response
"""
cas_resp = make_external_response(release=release)
validated_credentials = cas.validate_external_credential(cas_resp.user)
if user:
user = UserFactory.build()
user.external_identity = {validated_credentials["provider"]: {validated_credentials["id"]: "VERIFIED"}}
user.save()
return user, validated_credentials, cas_resp
else:
user = {
"external_id_provider": validated_credentials["provider"],
"external_id": validated_credentials["id"],
"fullname": validated_credentials["id"],
"access_token": cas_resp.attributes["accessToken"],
}
return user, validated_credentials, cas_resp
def setUp(self):
super(TestUsers, self).setUp()
self.user_one = UserFactory.build()
self.user_one.save()
self.user_two = UserFactory.build()
self.user_two.save()
def test_login_with_incorrect_password_returns_false(self):
user = UserFactory.build()
user.set_password('rhapsody')
user.save()
with assert_raises(auth.PasswordIncorrectError):
auth.login(user.username, 'wrongpassword')
def setUp(self):
ApiTestCase.setUp(self)
self.user_one = UserFactory.build()
self.user_one.save()
self.user_two = UserFactory.build()
self.user_two.save()
def user(self):
return UserFactory.build(
email='*****@*****.**',
username='******',
)
def test_create_request_user(self):
user = UserFactory.build()
request = self.create_request(user=user)
assert request.user == user
