class VideoFactory(factory.DictFactory):
type = settings.RESOURCE_CH_TYPE_VIDEO_VIMEO
status = settings.RESOURCE_PROVIDER_STATUS_AVAILABLE
name = factory.Sequence(lambda x: faker.word() + str(faker.pyint()))
description = factory.Sequence(lambda x: faker.text())
link = factory.Sequence(
lambda x: 'https://vimeo.com/' + str(faker.pyint()))
url = factory.Sequence(lambda x: faker.url())
sections = [settings.RESOURCE_CH_SECTION_SPRINT_AUTOMATED]
thumbnail = factory.Sequence(lambda x: faker.url())
duration = factory.Sequence(lambda x: faker.random_digit())
modified = factory.Sequence(lambda x: faker.date_time_this_year(
before_now=True, tzinfo=pytz.timezone('utc')).isoformat())
pictures = {
"sizes": [{
"link":
"https://i.vimeocdn.com/video/686815740_100x75.jpg?r=pad",
}, {
"link":
"https://i.vimeocdn.com/video/686815740_200x150.jpg?r=pad",
}, {
"link":
"https://i.vimeocdn.com/video/686815740_295x166.jpg?r=pad",
}]
}
class FakeAssignmentResourceItemFactory(django.DjangoModelFactory):
class Meta:
model = AssignmentResourceItem
assignment_resource = factory.SubFactory(
'assignment.faker_factories.assignment.FakeAssignmentResourceFactory')
name = factory.LazyAttribute(lambda x: faker.word())
description = factory.LazyAttribute(lambda x: faker.text())
thumbnail = factory.LazyAttribute(lambda x: faker.url())
iframe = ''
link = factory.LazyAttribute(lambda x: faker.url())
created_by = factory.SubFactory(
'exo_accounts.test_mixins.faker_factories.FakeUserFactory')
def test_change_profile_summary(self):
consultant = FakeConsultantFactory.create(
user__is_active=True,
user__password='******',
)
self.client.login(
username=consultant.user.email,
password='******',
)
url = reverse(
'api:profile:about-you',
kwargs={'pk': consultant.user.pk},
)
data = {
'bio_me': faker.paragraph(),
'linkedin': faker.word(),
'website': faker.url(),
'twitter': faker.word(),
}
response = self.client.put(url, data=data, format='json')
self.assertTrue(status.is_success(response.status_code))
consultant.user.refresh_from_db()
user = consultant.user
self.assertEqual(user.bio_me, data['bio_me'])
profile = ConsultantProfileRequirement()
self.assertTrue(
profile.get_consultant_requirement(
ConsultantProfileRequirement.KEY_SUMMARY,
consultant,
),
)
self.assertEqual(user.linkedin.value, data['linkedin'])
self.assertEqual(user.twitter.value, data['twitter'])
self.assertEqual(user.website.value, data['website'])
class FakeResourceFactory(django.DjangoModelFactory):
"""
Creates a fake consultant.
"""
class Meta:
model = Resource
created_by = factory.SubFactory(FakeUserFactory)
name = factory.LazyAttribute(lambda x: faker.text(max_nb_chars=20))
description = factory.LazyAttribute(lambda x: faker.text())
file = factory.django.FileField()
link = factory.LazyAttribute(lambda x: faker.url())
@factory.post_generation
def tags(self, create, extracted, **kwargs):
if not create:
# Simple build, do nothing.
return
if extracted:
# A list of groups were passed in, use them
for tag in extracted:
self.tags.add(tag)
else:
for tag in FakeTagFactory.create_batch(size=3):
self.tags.add(tag)
def test_send_mail_without_notify_webhook(self, request_mock):
# PREPARE DATA
template = 'accounts_change_password'
url_reverse = reverse('api:mail-list')
params = {
'name': faker.name(),
'public_url': faker.url(),
'recipients': [faker.email()],
}
data = {
'template': template,
'params': json.dumps(params),
'lang': 'en',
}
m = MultipartEncoder(fields=data)
# DO ACTION
with self.settings(
EMAIL_BACKEND='mail.backend.StoreBackend',
EXOMAILER_STORAGE='django.core.files.storage.FileSystemStorage',
EXOMAILER_STORAGE_OPTIONS={}):
self.client.post(
url_reverse,
data=m.to_string(),
content_type=m.content_type,
)
# ASSERTS
self.assertFalse(request_mock.called)
self.assertIsNone(request_mock.call_args)
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_send_mail_with_notify_webhook(self, request_mock):
# PREPARE DATA
template = 'accounts_change_password'
url_reverse = reverse('api:mail-list')
notify_webhook_url = faker.url()
params = {
'name': faker.name(),
'public_url': faker.url(),
'recipients': [faker.email()],
'notify_webhook': notify_webhook_url,
}
data = {
'template': template,
'params': json.dumps(params),
'lang': 'en',
}
m = MultipartEncoder(fields=data)
# DO ACTION
with self.settings(
EMAIL_BACKEND='mail.backend.StoreBackend',
EXOMAILER_STORAGE='django.core.files.storage.FileSystemStorage',
EXOMAILER_STORAGE_OPTIONS={}):
self.client.post(
url_reverse,
data=m.to_string(),
content_type=m.content_type,
)
# ASSERTS
requested_url, request_params = request_mock.call_args
self.assertTrue(request_mock.called)
self.assertEqual(requested_url[0], notify_webhook_url)
self.assertEqual(
request_params.get('data').get('email_status'),
settings.MAIL_NOTIFY_WEBHOOK_STATUS_OK
)
email_url = '{}{}'.format(
settings.DOMAIN_NAME,
reverse('mail:inbox-message', kwargs={'pk': 9999})
).replace('9999/', '')
email_url_sent = request_params.get('data').get('email_url')
self.assertTrue(email_url in email_url_sent)
class FakeContactFactoryMixin(factory.Factory):
phone = factory.LazyAttribute(lambda x: faker.phone_number())
website = factory.LazyAttribute(lambda x: faker.url())
address = factory.LazyAttribute(lambda x: faker.address())
postcode = factory.LazyAttribute(lambda x: faker.postcode())
contact_person = factory.LazyAttribute(lambda x: '{},\n{},\n{}'.format(
faker.name(),
faker.company_email(),
faker.phone_number(),
))
def test_validate_url_wrong(self):
# PREPARE DATA
url_api = reverse('api:resources:validate-url')
url_validate = faker.url()
# DO ACTION
response = self.client.post(url_api, data={'url': url_validate})
# ASSERTS
self.assertTrue(status.is_client_error(response.status_code))
def test_update_consultant_video_profile_with_no_perms_edit_consultant_profile(
self):
# PREPARE DATA
consultant = FakeConsultantFactory.create()
self.client.login(username=self.user.email, password='******')
url = reverse('api:profile:update-profile-video', args=[consultant.pk])
data = {'video_url': faker.url()}
# DO ACTION
response = self.client.put(url, data=data)
# ASSERTS
self.assertTrue(status.is_client_error(response.status_code))
def test_parse_urls_without_html_tags(self):
# PREPARE DATA
faked_url = faker.url()
faked_text = faker.text()
text_to_parse = '<p>{}</p>{}'.format(faked_text, faked_url)
# DO ACTION
text_parsed = parse_urls(text_to_parse)
# ASSERTIONS
self.assertEqual(
'<p>{}</p><a href="{}" rel="nofollow">{}</a>'.format(
faked_text, faked_url, faked_url), text_parsed)
def test_parse_urls_with_html_tags(self):
# PREPARE DATA
faked_text = faker.text()
faked_url = faker.url()
faked_url_text = ' '.join(faker.words())
text_to_parse = '<p>{}</p><a href="{}" rel="nofollow">{}</a>'.format(
faked_text, faked_url, faked_url_text)
# DO ACTION
parsed_text = parse_urls(text_to_parse)
# ASSERTIONS
self.assertEqual(text_to_parse, parsed_text)
class FakeResourceFactory(django.DjangoModelFactory):
class Meta:
model = Resource
status = settings.RESOURCE_CH_STATUS_DRAFT
type = settings.RESOURCE_CH_TYPE_VIDEO_VIMEO
name = factory.Sequence(lambda x: faker.word())
description = factory.Sequence(lambda x: faker.text())
link = factory.Sequence(lambda x: 'https://vimeo.com/' + str(faker.pyint()))
url = factory.Sequence(lambda x: faker.url())
thumbnail = factory.Sequence(lambda x: faker.uri())
duration = factory.Sequence(lambda x: faker.random_digit())
sections = [settings.RESOURCE_CH_SECTION_SPRINT_AUTOMATED]
projects = ''
extra_data = ''
def test_update_consultant_video_profile_from_url(self):
# PREPARE DATA
consultant = FakeConsultantFactory.create()
self.client.login(username=consultant.user.email,
password=consultant.user.short_name)
url = reverse('api:profile:update-profile-video', args=[consultant.pk])
data = {'video_url': faker.url()}
# DO ACTION
response = self.client.put(url, data=data)
# ASSERTS
consultant.exo_profile.refresh_from_db()
self.assertTrue(status.is_success(response.status_code))
self.assertEqual(consultant.exo_profile.video_url,
data.get('video_url'))
def test_validation_sprint_automated_feedbacks_validator(self):
# PREPARE DATA
self.prepare_data()
steps_with_feedbacks = Step.objects.filter_by_project(self.project).filter_by_index_range(
start=settings.SPRINT_AUTOMATED_STEP_INDEX_FEEDBACK_START,
end=settings.SPRINT_AUTOMATED_STEP_INDEX_FEEDBACK_END)
streams = StepStream.objects.filter(step__in=steps_with_feedbacks)
feedbacks_list_id = streams.values_list('typeform_feedback', flat=True)
feedbacks = GenericTypeformFeedback.objects.filter(id__in=feedbacks_list_id)
validator = SprintAutomatedFeedbacksValidator(self.project)
# DO ACTION
for feedback in feedbacks:
feedback.url = faker.url()
feedback.save()
# ASSERTS
is_pending_validation = validator.validate()
self.assertFalse(is_pending_validation)
class FakeProjectFactory(django.DjangoModelFactory):
class Meta:
model = Project
name = factory.LazyAttribute(lambda x: faker.word() + faker.numerify())
customer = factory.SubFactory(
'customer.faker_factories.FakeCustomerFactory')
start = factory.LazyAttribute(
lambda x: faker.date_time(tzinfo=string_to_timezone('utc')), )
duration = 3
lapse = settings.PROJECT_LAPSE_WEEK
agenda = factory.LazyAttribute(lambda x: faker.url())
created_by = factory.SubFactory(FakeUserFactory)
location = factory.LazyAttribute(
lambda x: '{}, {}'.format(faker.city(), faker.country()))
timezone = factory.LazyAttribute(lambda x: faker.timezone())
@factory.post_generation
def consultants(self, created, extracted, **kwargs):
if not created:
return None
if extracted:
for consultant in extracted:
new_consultant = FakeConsultantProjectRoleFactory(
project=self,
consultant=consultant,
)
new_consultant.save()
@factory.post_generation
def partners(self, created, extracted, **kwargs):
if not created:
return None
if extracted:
for partner in extracted:
new_partner = FakePartnerProjectRoleFactory(
project=self,
partner=partner,
)
new_partner.save()
def test_send_mail(self, mock_send_mail_handler):
# PREPARE DATA
template = "accounts_change_password"
url_reverse = reverse('api:mail-list')
params = {
"name": faker.name(),
"public_url": faker.url(),
"recipients": [faker.email()],
}
data = {
"template": template,
"params": json.dumps(params),
"lang": "en",
}
m = MultipartEncoder(fields=data)
# DO ACTION
response = self.client.post(url_reverse,
data=m.to_string(),
content_type=m.content_type)
# ASSERTS
self.assertTrue(status.is_success(response.status_code))
self.assertTrue(mock_send_mail_handler.called)
def test_edit_resource_url(self):
# PREPARE DATA
video = FakeResourceFactory.create()
tag = self._create_tag(commit=True)
tags = [tag.pk]
url = reverse('api:resources:library-detail', kwargs={'pk': video.pk})
old_video_url = video.url
data = {
'name': faker.word(),
'description': faker.text(),
'url': faker.url(),
'tags': tags
}
self._add_permissions_for_library_to_user()
# DO ACTION
response = self.client.put(url, data=data)
video.refresh_from_db()
# ASSERTS
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(old_video_url, video.url)
self.assertTrue(self._exists_tag_in_last_resource(tag.pk))
def get_payment_mock():
return {
'paymentUuid': faker.word(),
'nextUrl': faker.url(),
}
class VideoUploadFactory(factory.DictFactory):
url = factory.Sequence(lambda x: faker.url())
name = factory.Sequence(lambda x: faker.word() + str(faker.pyint()))
description = factory.Sequence(lambda x: faker.text())
sections = [settings.RESOURCE_CH_SECTION_SPRINT_AUTOMATED]
tags = []
def url(anon, obj, field, val):
return faker.url()
class FakeMicroLearningFactory(django.DjangoModelFactory):
class Meta:
model = MicroLearning
typeform_url = factory.LazyAttribute(lambda x: faker.url())
