def test_change_email(self, mock_send_verification):
user_email = faker.email()
user_pwd = faker.text()
user = get_user_model().objects.create_user(
email=user_email, password=user_pwd, short_name=faker.first_name())
response = models.EmailAddress.objects.check_email(user, user_email)
self.assertTrue(response[0])
user_email2 = faker.email()
email_address = models.EmailAddress.objects.add_email(
user, user_email2)
response = models.EmailAddress.objects.check_email(user, user_email2)
self.assertFalse(response[0])
self.assertEqual(response[1],
settings.EXO_ACCOUNTS_VALIDATION_CHOICES_NOT_VERIFIED)
email_address.verified_at = timezone.now()
email_address.save()
user.refresh_from_db()
self.assertEqual(user.email, user_email)
response = models.EmailAddress.objects.check_email(user, user_email2)
self.assertTrue(response[0])
self.assertEqual(response[1],
settings.EXO_ACCOUNTS_VALIDATION_CHOICES_VERIFIED)
other_email = faker.email()
get_user_model().objects.create_user(email=other_email,
password=user_pwd,
short_name=faker.first_name())
response = models.EmailAddress.objects.check_email(user, other_email)
self.assertFalse(response[0])
self.assertEqual(response[1],
settings.EXO_ACCOUNTS_VALIDATION_CHOICES_OTHER_USER)
response = models.EmailAddress.objects.check_email(user, faker.email())
self.assertTrue(response[0])
self.assertEqual(response[1],
settings.EXO_ACCOUNTS_VALIDATION_CHOICES_PENDING)
def test_get_or_create(self):
name = faker.first_name()
email = faker.email()
user, created = User.objects.get_or_create(
email=email, defaults={'short_name': name})
self.assertTrue(created)
self.assertIsNotNone(user)
self.assertEqual(user.email, email)
self.assertEqual(user.short_name, name)
self.assertTrue(user.has_usable_password())
user2 = User.objects.get_or_create(
email=faker.email(), defaults={'short_name': faker.first_name()})
self.assertIsNotNone(user2)
user3, created = User.objects.get_or_create(email=faker.email(),
defaults={
'short_name':
name,
'full_name':
'{} {}'.format(
faker.first_name(),
faker.last_name()),
'is_active':
True,
'password':
name
})
self.assertIsNotNone(user3)
self.assertTrue(created)
self.assertNotEqual(user3.full_name, '')
self.assertTrue(user3.has_usable_password())
self.assertTrue(user3.is_active)
self.assertTrue(user3.check_password(name))
user4, created = User.objects.get_or_create(email=email)
self.assertFalse(created)
self.assertEqual(user4.id, user.id)
def test_filter_by_name(self):
first_name1 = faker.first_name() + faker.numerify()
last_name1 = faker.last_name() + faker.numerify()
first_name2 = faker.first_name() + faker.numerify()
last_name2 = faker.last_name() + faker.numerify()
FakeConsultantFactory.create(
user__short_name=first_name1,
user__full_name=last_name1,
)
FakeConsultantFactory.create(
user__short_name=first_name2,
user__full_name=last_name2,
)
FakeConsultantFactory.create(
user__short_name=first_name1,
user__full_name=last_name2,
)
FakeConsultantFactory.create(
user__short_name=first_name2,
user__full_name=last_name1,
)
queryset = Consultant.all_objects.all()
filter = {'name': first_name1}
self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 2)
filter = {'name': last_name2}
self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 2)
filter = {'name': first_name1 + ' ' + last_name2}
self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 3)
filter = {'name': first_name1 + ' ' + first_name2}
self.assertEqual(queryset.filter_complex(*filter, **filter).count(), 4)
def test_change_summary_not_required(self):
# PREPARE DATA
consultant = FakeConsultantFactory.create(
user__is_active=True,
user__bio_me=None,
user__password='******',
)
self.client.login(
username=consultant.user.email,
password='******',
)
url = reverse(
'api:profile:summary',
kwargs={'pk': consultant.user.pk},
)
data = {
'short_name': faker.first_name(),
'full_name': '',
'timezone': 'Canada/Eastern',
}
# DO ACTION
response = self.client.put(url, data=data, format='json')
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
consultant.user.refresh_from_db()
consultant.refresh_from_db()
user = consultant.user
self.assertEqual(user.short_name, data['short_name'])
self.assertEqual(consultant.languages.count(), 0)
self.assertEqual(user.timezone.zone, 'Canada/Eastern')
def test_sprint_launch(self):
sprint = self.customer.create_sprint_automated(
self.super_user,
faker.first_name(),
start=timezone.now(),
description='',
)
project = sprint.project_ptr
new_user_email = faker.email()
new_user_name = faker.name()
team = FakeTeamFactory.create(
project=sprint.project_ptr,
user_from=self.super_user,
coach__user__is_active=True,
)
member = team.add_member(
user_from=self.super_user,
email=new_user_email,
name=new_user_name,
)
project_setting = project.settings
fixed_pass = faker.password()
project_setting.launch['send_welcome_participant'] = False
project_setting.launch['send_welcome_consultant'] = True
project_setting.launch['fix_password'] = fixed_pass
project_setting.save()
mail.outbox = []
project.launch(self.super_user, start_date=timezone.now())
member.refresh_from_db()
self.assertEqual(len(mail.outbox), 1)
self.assertTrue(member.check_password(fixed_pass))
def test_filter_simple(self):
first_name = faker.first_name()
wrong_name = faker.numerify()
language_esp = Language.objects.get(name='Spanish')
language_eng = Language.objects.get(name='English')
FakeConsultantFactory.create(
user__short_name=first_name,
languages=[language_esp],
)
FakeConsultantFactory.create(
user__short_name=wrong_name,
user__full_name=wrong_name,
languages=[language_esp],
)
FakeConsultantFactory.create(
user__short_name=wrong_name,
user__full_name=wrong_name,
languages=[language_eng],
)
filter = {'name': first_name}
self.assertEqual(
Consultant.all_objects.filter_complex(*filter, **filter).count(),
1)
filter = {'language': language_esp}
self.assertEqual(
Consultant.all_objects.filter_complex(*filter, **filter).count(),
2)
def test_api_create_no_members(self, task_handler):
coaches = FakeConsultantFactory.create_batch(
size=3,
user__is_active=True,
status=settings.CONSULTANT_STATUS_CH_ACTIVE,
)
for coach in coaches:
ConsultantProjectRole.objects.get_or_create_consultant(
user_from=self.super_user,
consultant=coach,
project=self.sprint.project_ptr,
exo_role=ExORole.objects.get(
code=settings.EXO_ROLE_CODE_SPRINT_COACH),
)
self.client.login(username=self.super_user.username, password='******')
url = reverse('api:project:team:create',
kwargs={'project_id': self.sprint.project_ptr.pk})
data = {
'name': faker.first_name(),
'stream': 'S',
'zoom_id': faker.word(),
'coach': coaches[0].pk,
'team_members': [],
}
response = self.client.post(url, data=data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(
Team.objects.filter(project=self.sprint.project_ptr).count(), 1)
def test_delete_team(self):
new_team = FakeTeamFactory(
user_from=self.super_user,
coach__user__is_active=True,
)
member = new_team.add_member(
user_from=self.super_user,
email=faker.email(),
name=faker.first_name(),
)
coach = new_team.coach
new_team.delete()
self.assertFalse(
member.has_perm(
settings.TEAM_PERMS_FULL_VIEW_TEAM,
new_team,
))
self.assertFalse(
coach.user.has_perm(
settings.TEAM_PERMS_FULL_VIEW_TEAM,
new_team,
))
self.assertFalse(
coach.user.has_perm(
settings.TEAM_PERMS_COACH_TEAM,
new_team,
))
def create_team_api(self):
coaches = FakeConsultantFactory.create_batch(
size=4,
user__is_active=True,
status=settings.CONSULTANT_STATUS_CH_ACTIVE,
)
for coach in coaches:
ConsultantProjectRole.objects.get_or_create_consultant(
user_from=self.super_user,
consultant=coach,
project=self.sprint.project_ptr,
exo_role=ExORole.objects.get(
code=settings.EXO_ROLE_CODE_SPRINT_COACH),
)
self.client.login(username=self.super_user.username, password='******')
url = reverse('api:project:team:create',
kwargs={'project_id': self.sprint.project_ptr.pk})
members = []
for k in range(5):
name = faker.word()
email = faker.email()
members.append({'short_name': name, 'email': email})
data = {
'name': faker.first_name(),
'stream': 'S',
'zoom_id': faker.word(),
'coach': coaches[0].pk,
'team_members': members,
}
response = self.client.post(url, data=data, format='json')
return response, coaches
def test_change_previous_used_email(self, mock_send_verification):
admin_user = FakeUserFactory.create(is_superuser=True, is_active=True)
user_email = faker.email()
user_pwd = faker.text()
user = get_user_model().objects.create_user(
email=user_email, password=user_pwd, short_name=faker.first_name())
unused_email = faker.email()
email = models.EmailAddress.objects.create(user=user,
email=unused_email)
self.assertFalse(email.is_verified)
self.assertEqual(user.email, user_email)
# own user
status, _ = models.EmailAddress.objects.change_user_email(
user, user, unused_email)
self.assertFalse(status)
user.refresh_from_db()
self.assertEqual(user.email, user_email)
self.assertTrue(mock_send_verification.called)
mock_send_verification.reset_mock()
# admin user
status, _ = models.EmailAddress.objects.change_user_email(
admin_user, user, unused_email)
self.assertTrue(status)
user.refresh_from_db()
self.assertEqual(user.email, unused_email)
self.assertFalse(mock_send_verification.called)
# Return a previous email already verified
status, _ = models.EmailAddress.objects.change_user_email(
user, user, user_email)
self.assertTrue(status)
user.refresh_from_db()
self.assertEqual(user.email, user_email)
self.assertFalse(mock_send_verification.called)
def test_accept_profile_user_optionals(self):
# PREPARE DATA
consultant, invitation = self.create_validation_agreement(
settings.CONSULTANT_VALIDATION_BASIC_PROFILE, )
self.client.login(
username=consultant.user.email,
password='******',
)
url = reverse(
'api:invitation:invitation-accept',
kwargs={'hash': invitation.hash},
)
location_granada = 'Granada, Spain'
place_id_granada = 'ChIJfcIyLeb8cQ0Rcg1g0533WJI'
data = {
'profilePicture': '',
'shortName': faker.first_name(),
'fullName': faker.name(),
'location': location_granada,
'placeId': place_id_granada,
}
# DO ACTION
response = self.client.post(url, data=data, format='json')
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
invitation.refresh_from_db()
self.assertTrue(invitation.is_active)
consultant.refresh_from_db()
user = consultant.user
user.refresh_from_db()
self.assertIsNotNone(user.profile_picture)
self.assertIsNotNone(user.timezone)
def test_create_step2_executed(self):
# DO ACTION
self.consultant = Consultant.objects.create_consultant(
short_name=faker.first_name(),
email=faker.email(),
invite_user=self.super_user,
registration_process=True,
version=3,
)
mail.outbox = []
process = self.consultant.registration_process
step = process.steps.first()
invitation = step.invitation
invitation.accept(invitation.user)
# ASSETS
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, [self.super_user.email])
# DO ACTION
current_step = process.current_step
invitation = current_step.invitation
mail.outbox = []
self.assertTrue(self.consultant.agreement.is_pending)
invitation.accept(self.consultant.user)
# ASSETS
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, [self.super_user.email])
self.assertIsNotNone(self.consultant.agreement)
self.assertTrue(self.consultant.agreement.is_accepted)
circle = Circle.objects.filter(name__icontains='Community').get()
self.assertFalse(self.consultant.user in circle.followers)
def get_mock_data(self, optional=True):
mock_data = {
'name': faker.first_name(),
'email': faker.email(),
'step_name': faker.word(),
}
return mock_data
def test_create_step1_executed(self):
# DO ACTION
mail.outbox = []
self.consultant = Consultant.objects.create_consultant(
short_name=faker.first_name(),
email=faker.email(),
invite_user=self.super_user,
registration_process=True,
version=3,
)
# ASSERTS
process = self.consultant.registration_process
self.assertTrue(self.consultant.user.has_usable_password())
self.assertEqual(len(mail.outbox), 1)
# DO ACTION
step = process.steps.first()
invitation = step.invitation
new_password = faker.word()
invitation.accept(invitation.user, password=new_password)
step.refresh_from_db()
# ASSETS
self.consultant = Consultant.all_objects.get(pk=self.consultant.pk)
self.assertEqual(self.consultant.user.email, invitation.user.email)
self.assertTrue(self.consultant.user.check_password(new_password))
self.assertTrue(step.is_executed)
self.assertTrue(invitation.is_active)
circle = Circle.objects.filter(name__icontains='Community').get()
self.assertFalse(self.consultant.user in circle.followers)
def test_create_step1_executed_change_email(self):
# DO ACTION
mail.outbox = []
original_email = faker.email()
self.consultant = Consultant.objects.create_consultant(
short_name=faker.first_name(),
email=original_email,
invite_user=self.super_user,
registration_process=True,
version=3,
)
# ASSETS
process = self.consultant.registration_process
step = process.steps.first()
invitation = step.invitation
new_password = faker.word()
new_email = faker.email()
mail.outbox = []
invitation.accept(invitation.user, email=new_email, password=new_password)
self.consultant = Consultant.all_objects.get(pk=self.consultant.pk)
self.assertEqual(self.consultant.user.email, original_email)
self.assertTrue(self.consultant.user.emailaddress_set.get(email=original_email).is_verified)
self.assertFalse(self.consultant.user.emailaddress_set.get(email=new_email).is_verified)
# one to network-admin and other for validation email
self.assertEqual(len(mail.outbox), 2)
def test_create_step3_executed(self):
# DO ACTION
self.consultant = Consultant.objects.create_consultant(
short_name=faker.first_name(),
email=faker.email(),
invite_user=self.super_user,
registration_process=True,
version=3,
)
process = self.consultant.registration_process
step = process.steps.first()
invitation = step.invitation
invitation.accept(invitation.user)
current_step = process.current_step
invitation = current_step.invitation
invitation.accept(self.consultant.user)
invitation = process.current_step.invitation
invitation.accept(invitation.user)
consultant_default_circles = Circle.objects.filter(
name__in=settings.CIRCLES_FOR_CONSULTANTS)
# ASSERTS
self.assertTrue(process.is_registered)
self.consultant.refresh_from_db()
self.assertTrue(self.consultant.is_active)
self.assertEqual(
set(list(following(self.consultant.user, Circle))),
set(list(consultant_default_circles)),
)
def test_upload_members(self, mock_request):
# PREPARE DATA
self.init_mock(mock_request)
self.setup_credentials(self.super_user)
url = reverse(
'api:event:participant-upload',
kwargs={'event_id': self.event.uuid.__str__()},
)
content = ''
for k in range(10):
full_name = '{} {}'.format(faker.first_name(), faker.last_name())
content += '{},{}\n'.format(full_name, faker.email())
data = {
'content': content,
'exo_role': settings.EXO_ROLE_CODE_SUMMIT_PARTICIPANT,
}
# DO ACTION
response = self.client.post(url, data=data, format='json')
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(len(response.data), 10)
self.assertEqual(self.event.participants.count(), 10)
def test_add_member_no_customer(self):
# PREPARE DATA
url = reverse(
'api:relation:project:userprojectrole-list',
kwargs={'project_id': self.sprint.project_ptr.pk},
)
data = {
'name': '{} {}'.format(faker.first_name(), faker.last_name()),
'email': faker.email(),
'exo_role': settings.EXO_ROLE_CODE_SPRINT_PARTICIPANT,
}
self.client.login(username=self.user.email, password='******')
# DO ACTION
response = self.client.post(url, data=data, format='json')
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(
self.sprint.project_ptr.users_roles.filter(
user__email=data['email']).count(), 1)
role = UserProjectRole.objects.filter(
project=self.sprint.project_ptr,
user__email=data['email']).first()
self.assertEqual(Invitation.objects.filter_by_object(role).count(), 1)
invitation = Invitation.objects.filter_by_object(role)[0]
self.assertTrue(invitation.is_pending)
self.assertTrue(role.is_inactive)
self.assertEqual(role.user.short_name, data['name'].split(' ')[0])
self.assertEqual(role.user.full_name, data['name'])
def test_do_logout_step3(self):
# PREPARE DATA
self.consultant = Consultant.objects.create_consultant(
short_name=faker.first_name(),
email=faker.email(),
invite_user=self.super_user,
registration_process=True,
version=3,
)
process = self.consultant.registration_process
step = process.steps.first()
invitation = step.invitation
invitation.accept(invitation.user)
current_step = process.current_step
invitation = current_step.invitation
invitation.accept(self.consultant.user)
mock = Mock()
self.middleware = ConsultantActivationMiddleware(mock)
# DO ACTION
self.request.path = '/accounts/logout/'
self.request.user = self.consultant.user
response = self.middleware(self.request)
# ASSERTS
self.assertIsNotNone(response)
self.assertTrue(isinstance(response, Mock))
def test_lauch_project_and_check_team_invitations(self):
project = FakeProjectFactory()
users = [{
'email': faker.email(),
'name': faker.first_name()
} for _ in range(2)]
team = FakeTeamFactory(project=project)
team.update_members(self.super_user, members=users)
for team_member in team.team_members.all():
team_member_team_invitation = Invitation.objects.filter_by_object(team) \
.filter(user=team_member)
self.assertEqual(team_member_team_invitation.count(), 1)
self.assertTrue(team_member_team_invitation.first().is_pending)
self.assertFalse(project.autoactive)
project.launch(self.super_user, start_date=timezone.now())
self.assertTrue(project.autoactive)
for team_member in team.team_members.all():
team_member_team_invitation = Invitation.objects.filter_by_object(team) \
.filter(user=team_member)
self.assertEqual(team_member_team_invitation.count(), 1)
self.assertTrue(team_member_team_invitation.first().is_active)
project.set_started(self.super_user, timezone.now())
for team_member in team.team_members.all():
team_member_team_invitation = Invitation.objects.filter_by_object(team) \
.filter(user=team_member)
self.assertEqual(team_member_team_invitation.count(), 1)
self.assertTrue(team_member_team_invitation.first().is_active)
# ##
# Add a new Member and test SignUp invitaion is active
# ##
new_user = {'email': faker.email(), 'name': faker.first_name()}
team.update_members(user_from=self.super_user, members=[new_user])
new_member = get_user_model().objects.get(email=new_user.get('email'))
team_member_team_invitation = Invitation.objects.filter_by_object(team) \
.filter(user=new_member)
self.assertEqual(team_member_team_invitation.count(), 1)
self.assertTrue(team_member_team_invitation.first().is_active)
def test_create_user(self):
user_email = faker.email().upper()
user_pwd = faker.text()
user = get_user_model().objects.create_user(
email=user_email, password=user_pwd, short_name=faker.first_name())
self.assertTrue(user.emailaddress_set.all().count() > 0)
self.assertTrue(user.emailaddress_set.all()[0].is_verified)
self.assertEqual(user.email, user_email.lower())
def get_mock_data(self, optional=True):
mock_data = {
'user': faker.first_name(),
'email': faker.email(),
'public_url': faker.url()
}
return mock_data
def test_default_create_user(self):
# ##
# By default set a NOT USABLE password
# ##
user = User.objects.create_user(email=faker.email(),
short_name=faker.first_name())
self.assertTrue(user.has_usable_password())
self.assertTrue(user.can_authenticate)
def save_user(user):
user.short_name = faker.first_name()
user.full_name = faker.name()
user.email = email(user)
user.bio_me = faker.text()
user.short_me = faker.text()
user.about_me = faker.text()
user.profile_picture.name = None
user.profile_picture_origin = settings.EXO_ACCOUNTS_PROFILE_PICTURE_CH_DEFAULT
user.save()
return user
def generate_fake_data(self):
return {
'uuid': uuid.uuid4().__str__(),
'short_name': faker.first_name(),
'full_name': faker.name(),
'email': faker.email(),
'password': faker.password(),
'is_active': True,
'is_superuser': False,
'is_staff': False,
}
def test_change_email(self, mock_send_verification):
user_email = faker.email()
user_pwd = faker.text()
user = get_user_model().objects.create_user(
email=user_email,
password=user_pwd,
short_name=faker.first_name(),
)
url = reverse('api:accounts:validate-email')
# Logged user
self.client.login(username=self.super_user.email, password='******')
data = {
'user': user.pk,
'email': user_email,
}
# admin user
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_success(response.status_code))
# own user
self.client.login(username=user.email, password=user_pwd)
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_success(response.status_code))
# ##
# not valid email
# ##
other_email = faker.email()
get_user_model().objects.create_user(
email=other_email,
password=user_pwd,
short_name=faker.first_name(),
)
data['email'] = other_email
response = self.client.post(url, data=data, format='json')
self.assertTrue(status.is_client_error(response.status_code))
def test_get_or_create_several_emailaddress(self):
name = faker.first_name()
email = faker.email()
user, created = User.objects.get_or_create(
email=email, defaults={'short_name': name})
self.assertTrue(created)
email2 = faker.email()
user.add_email_address(email2)
user2, created = User.objects.get_or_create(
email=email2, defaults={'short_name': name})
self.assertFalse(created)
self.assertEqual(user2.pk, user.pk)
def test_create_user(self):
user_email = faker.email()
user_pwd = '123456789'
user = User.objects.create_user(email=user_email,
password=user_pwd,
short_name=faker.first_name())
self.assertIsNotNone(user.profile_picture)
self.assertTrue(user.profile_picture != '')
for size in user._meta.get_field('profile_picture').thumbnails:
self.assertIsNotNone(
user.profile_picture.get_thumbnail_url(size[0], size[1]))
def get_mock_data(self, optional=True):
"""Returns mock data for this mail, this will use to preview the html
or send mock args in the email
You need to maintain this method if you want better results
"""
mock_data = {
'name': faker.first_name(),
'email': faker.email(),
'message': faker.sentences(nb=3),
}
return mock_data
def get_mock_data(self, optional=True):
project_name = faker.word()
team_name = faker.word()
mock_data = {
'team_name': team_name,
'project_name': project_name,
'relation_name': '[relation_name]',
'user': faker.first_name(),
'is_coach': random.randint(0, 1),
'public_url': '/{}'.format(faker.uri_path()),
}
return mock_data
