def create_and_login_user(self):
url_name = "auth_views.login"
headers = self.get_csrf_headers(url_name)
u = UserFactory(email='*****@*****.**')
u.password = "******"
user_data = {'email': '*****@*****.**', 'password': '******'}
data, status = self.post_data(url_name, user_data, headers)
return data['user']
def _test_set_due_time_permissions(self, card, get_progress):
recruit = UserFactory()
staff_member = UserFactory(is_staff=True)
card.assignees.add(recruit)
due_time_1 = timezone.now() + timedelta(days=7)
due_time_2 = timezone.now() + timedelta(days=1)
url = reverse("agilecard-set-card-due-time", kwargs={"pk": card.id})
self.login(UserFactory())
response = self.client.post(url, data={"due_time": due_time_1})
self.assertEqual(response.status_code, 403)
self.assertEqual(response.data["detail"].code, "permission_denied")
self.login(recruit)
response = self.client.post(url, data={"due_time": due_time_1})
self.assertEqual(response.status_code, 200)
card.refresh_from_db()
progress = get_progress(card)
self.assertEqual(progress.due_time.strftime("%c"),
due_time_1.strftime("%c"))
response = self.client.post(url, data={"due_time": due_time_1})
self.assertEqual(response.status_code, 403)
self.assertEqual(response.data["detail"].code, "permission_denied")
self.login(staff_member)
response = self.client.post(url, data={"due_time": due_time_2})
self.assertEqual(response.status_code, 200)
progress.refresh_from_db()
self.assertEqual(progress.due_time.strftime("%c"),
due_time_2.strftime("%c"))
def test_get_company_users(client):
"""
Тест получения списка сотрудников компании
"""
company = CompanyFactory()
user1 = UserFactory(companies=[company])
user2 = UserFactory(companies=[company])
token = AuthToken.objects.create(user1)[1]
session = client.session
session['current_company_id'] = company.pk
session.save()
response = client.get(reverse('get_company_users'),
HTTP_AUTHORIZATION=f'Token {token}')
assert response.status_code == 200
assert len(response.data) == 2
def test_users_can_view_their_own_burndown_snapshot_objects(self):
burndown_snapshot_object = factories.BurndownSnapshotFactory(
user=UserFactory(is_superuser=False, is_staff=False))
self.login(burndown_snapshot_object.user)
response = self.client.get(
f"{self.api_url}?user__id={burndown_snapshot_object.user.id}")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data[0].get("user"),
burndown_snapshot_object.user.id)
def test_existing_user_gets_logged_in(self, get_email_from_one_time_code):
user = UserFactory()
user = User.objects.get(email=user.email)
get_email_from_one_time_code.return_value = user.email
# breakpoint()
response = self.make_request()
self.assertEqual(response.status_code, status.HTTP_200_OK)
token_value = response.data["token"]
Token.objects.get(key=token_value)
def test_user_with_permission_can_view_admin_reports_link(self):
u = UserFactory.create_and_login(self.client)
u.user_permissions.add(
Permission.objects.get(codename='read_cvn_reports'))
u.user_permissions.add(
Permission.objects.get(codename='read_admin_menu'))
u.save()
soup = BeautifulSoup(self.client.get(reverse('cvn')).content, 'lxml')
reports_link = soup.select('a#admin_reports_link')
self.assertEqual(len(reports_link), 1)
def test_avatar_upload(client):
"""
Тест загрузки аватарки
"""
user = UserFactory()
token = AuthToken.objects.create(user)[1]
path = os.path.join(settings.BASE_DIR, 'core', 'tests', 'fixtures', "test_avatar.png")
data = {
'pk': user.pk,
'file': open(path, 'rb'),
}
response = client.post(reverse('avatar-upload'), data=data, HTTP_AUTHORIZATION=f'Token {token}')
user.refresh_from_db()
assert user.avatar is not None
assert response.status_code == 200
def test_form_valid(self):
user = UserFactory()
form = ProjectForm(data={'name': 'Hello World!'})
self.assertTrue(form.is_valid())
project = form.save(commit=False)
project.owner = user
project.save()
self.assertEqual(project.name, 'Hello World!')
self.assertEqual(project.owner, user)
self.assertIsNotNone(project.created)
self.assertIsNotNone(project.modified)
def test_no_tilde_reviews_done_in_last_7_days(self):
user = UserFactory()
# add a review, but it's too old to count
review = RecruitProjectReviewFactory(timestamp=self.two_weeks_ago,
reviewer_user=user)
review.timestamp = self.two_weeks_ago
review.save()
AgileCardFactory(recruit_project=review.recruit_project)
count = self.stats_serializer.get_tilde_reviews_done_last_7_days(user)
self.assertEqual(count, 0)
def test_login(client):
"""
Тест аутентификации пользователя
"""
data = {
'email': '*****@*****.**',
'password': '******',
}
UserFactory(email=data['email'], password=data['password'])
response = client.post(reverse('login'), data=data)
assert response.status_code == 200
def test_get_instance_permissions(self):
attendee_user = UserFactory(is_superuser=False, is_staff=False)
workshop_attendance = factories.WorkshopAttendanceFactory(
content_item=factories.ContentItemFactory(
content_type=ContentItem.WORKSHOP),
timestamp=timezone.now(),
attendee_user=attendee_user,
)
self.login(attendee_user)
url = self.get_list_url()
response = self.client.get(f"{url}{workshop_attendance.id}",
follow=True)
self.assertEqual(response.status_code, 200)
random_human = UserFactory(is_superuser=False, is_staff=False)
self.login(random_human)
response = self.client.get(f"{url}{workshop_attendance.id}",
follow=True)
self.assertEqual(response.status_code, 403)
self.assertEqual(response.data["detail"].code, "permission_denied")
def setUp(self):
self.project = ProjectFactory()
self.project.save()
# make some users
self.admin_user = UserFactory()
self.project.administrators.add(self.admin_user)
# get a default response
self.url = self.project.get_edit_url()
self.client.force_login(self.admin_user)
self.response = self.client.get(self.url)
def test_delete_producciones(self):
user = UserFactory.create()
cvn = CVN(user=user, pdf_path=get_cvn_path('CVN-Test'))
cvn.insert_xml()
cvn.remove_producciones()
self.assertEqual(user.profile.articulo_set.count(), 0)
self.assertEqual(user.profile.capitulo_set.count(), 0)
self.assertEqual(user.profile.congreso_set.count(), 0)
self.assertEqual(user.profile.convenio_set.count(), 0)
self.assertEqual(user.profile.libro_set.count(), 0)
self.assertEqual(user.profile.proyecto_set.count(), 0)
self.assertEqual(user.profile.tesisdoctoral_set.count(), 0)
def test_insert_xml_ull(self):
""" Insert the data of XML in the database """
user = UserFactory.create()
cvn = CVN(user=user, pdf_path=get_cvn_path('CVN-ULL'))
cvn.insert_xml()
self.assertEqual(user.profile.articulo_set.count(), 1214)
self.assertEqual(user.profile.libro_set.count(), 6)
self.assertEqual(user.profile.capitulo_set.count(), 32)
self.assertEqual(user.profile.congreso_set.count(), 55)
self.assertEqual(user.profile.convenio_set.count(), 38)
self.assertEqual(user.profile.proyecto_set.count(), 11)
self.assertEqual(user.profile.tesisdoctoral_set.count(), 0)
def test_api_users_select(client):
"""
Тест получения options для select-а с пользователями
"""
user = UserFactory(name='user_aaa')
token = AuthToken.objects.create(user)[1]
UserFactory(name='user_bbb')
UserFactory(name='user_bb_aa')
data = {
'q': 'bb',
}
response = client.get(reverse('api-users-select'),
data=data,
HTTP_AUTHORIZATION=f'Token {token}')
assert response.status_code == 200
assert len(response.data) == 2
def test_new_project_link(self, client):
"""A 'new project' link should be shown if logged-in user is authorized,
otherwise hidden."""
link_html = '<a href="/proj_create"'
project_index_url = reverse('project_list')
client.logout()
assert link_html not in client.get(project_index_url).rendered_content
client.force_login(UserFactory())
assert link_html in client.get(project_index_url).rendered_content
def test_set_project_link(self):
content_item = factories.ContentItemFactory(
content_type=ContentItem.PROJECT,
project_submission_type=ContentItem.LINK)
recruit = UserFactory(is_superuser=False, is_staff=False)
card = factories.AgileCardFactory(content_item=content_item,
# content_type= ContentItem.PROJECT,
)
card.assignees.add(recruit)
url = f"{self.get_list_url()}{card.id}/set_project_link/"
link_1 = "https://wnning.com"
link_2 = "https://wnning.com/boom"
self.login(recruit)
response = self.client.post(url, data={"link_submission": link_1})
self.assertEqual(response.status_code, 200)
project = card.recruit_project
project.refresh_from_db()
self.assertEqual(project.link_submission, link_1)
response = self.client.post(url, data={"link_submission": link_2})
project.refresh_from_db()
self.assertEqual(project.link_submission, link_2)
other_recruit = UserFactory(is_superuser=False, is_staff=False)
self.login(other_recruit)
response = self.client.post(url, data={"link_submission": link_1})
self.assertEqual(response.status_code, 403)
self.assertEqual(response.data["detail"].code, "permission_denied")
project.refresh_from_db()
self.assertEqual(project.link_submission, link_2)
class has_perm_Tests(TestCase):
def setUp(self):
self.user = UserFactory(is_superuser=False)
self.team = TeamFactory()
def test_returns_correctly_when_assigning_permissions_to_users(self):
self.assertEqual(
self.user.has_perm(Team.PERMISSION_ASSIGN_REVIEWERS, self.team), False
)
self.assertEqual(
self.user.has_perm(Team.PERMISSION_MANAGE_CARDS, self.team), False
)
assign_perm(Team.PERMISSION_MANAGE_CARDS, self.user, self.team)
self.assertEqual(
self.user.has_perm(Team.PERMISSION_ASSIGN_REVIEWERS, self.team), False
)
self.assertEqual(
self.user.has_perm(Team.PERMISSION_MANAGE_CARDS, self.team), True
)
def test_returns_correctly_when_assigning_permissions_to_managing_team(self):
managment_team = TeamFactory()
managment_team.users.add(self.user)
assign_perm(Team.PERMISSION_MANAGE_CARDS, managment_team, self.team)
self.assertEqual(
self.user.has_perm(Team.PERMISSION_ASSIGN_REVIEWERS, self.team), False
)
self.assertEqual(
self.user.has_perm(Team.PERMISSION_MANAGE_CARDS, self.team), True
)
def test_user_without_permission_can_view_reports(self):
u = UserFactory.create_and_login(self.client)
Department.objects.create(code=4987,
name="dept1",
members=[],
commit=True)
Area.objects.create(code=4987, name="area1", members=[], commit=True)
session = self.client.session # session has to be put in a variable
session['dept_code'] = 4987
session['area_code'] = 4987
session.save()
response = self.client.get(reverse('reports'))
self.assertEqual(response.status_code, 200)
def test_get_task(client):
"""
Тест получения данных по задаче
"""
user1 = UserFactory()
token = AuthToken.objects.create(user1)[1]
task = TaskFactory()
response = client.get(reverse('get-task-detail', args=(task.pk, )), HTTP_AUTHORIZATION=f'Token {token}')
assert response.status_code == 200
def test_add_remove(self):
user = UserFactory()
context = ExecutionContext(user=user,
plugin=self.plugin_info['1']['plugin'])
manager = PluginManager(context)
# This should be 1 because we have just added a plugin for the user.
plugin_key = self.plugin_info['1']['plugin'].hashkey
manager.add(plugin_key)
self.assertEqual(len(user.plugins), 1)
manager.remove(plugin_key)
self.assertEqual(len(user.plugins), 0)
def test_account_detail_api_view_not_owner(self):
"""
Ensure API view will return 404 status code to request with methods:
GET, PUT, DELETE, if requested account does not
belongs to authenticated user.
"""
another_user = UserFactory()
account = AccountFactory(manager=another_user)
self.run_method_status_code_check(
url=self.urls['account_detail'](kwargs={
'pk': account.pk
}),
methods=['get', 'put', 'delete'],
status_code=status.HTTP_404_NOT_FOUND)
def test_invite_user(client):
"""
Тест приглашения пользователя
"""
company = CompanyFactory()
user_one = UserFactory(companies=[company])
token = AuthToken.objects.create(user_one)[1]
user_two = UserFactory()
data = {'email': user_two.email}
session = client.session
session['current_company_id'] = company.pk
session.save()
response = client.post(reverse('invite-user'),
data=data,
HTTP_AUTHORIZATION=f'Token {token}')
assert response.status_code == 200
assert user_two.companies.filter(pk=company.pk).exists()
def test_on_insert_cvn_old_pdf_is_moved(self):
user = UserFactory.create()
cvn = CVN(user=user, pdf_path=get_cvn_path('CVN-Test'))
cvn.save()
filename = cvn.cvn_file.name.split('/')[-1].replace(
u'.pdf', u'-' +
str(cvn.uploaded_at.strftime('%Y-%m-%d-%Hh%Mm%Ss')) + u'.pdf')
old_cvn_path = os.path.join(
'/'.join(cvn.cvn_file.path.split('/')[:-1]), 'old', filename)
CVN(user=user, pdf_path=get_cvn_path('CVN-Test'))
self.assertTrue(os.path.isfile(old_cvn_path))
self.assertEqual(
OldCvnPdf.objects.filter(user_profile=user.profile,
uploaded_at=cvn.uploaded_at).count(), 1)
def test_annotating_with_total_norms_empty(self):
user = UserFactory()
DailyIntakesReportFactory(user=user)
annotated_daily_report = DailyIntakesReport.filter_for_user(
user).annotate_with_nutrient_totals().first()
self.assertEqual(annotated_daily_report.total_potassium_mg, 0)
self.assertEqual(annotated_daily_report.total_sodium_mg, 0)
self.assertEqual(annotated_daily_report.total_phosphorus_mg, 0)
self.assertEqual(annotated_daily_report.total_proteins_mg, 0)
self.assertEqual(annotated_daily_report.total_energy_kcal, 0)
self.assertEqual(annotated_daily_report.total_liquids_ml, 0)
def test_recover_password_two(self, mocker, client) -> None:
"""
Тест удачного создания письма
"""
user1 = UserFactory()
data = {
'email': user1.email,
}
response = client.post(reverse('recover-password'), data=data)
assert response.status_code == 200
email = Email.objects.first()
assert email is not None
def test_user_without_permission_cant_download_rcsv(self):
u = UserFactory.create_and_login(self.client)
session = self.client.session # session has to be put in a variable
session['dept_code'] = 4987
session['area_code'] = 4987
session.save()
self._create_dept_and_area_fake('2014', 4987, 'rcsv')
response = self.client.get(
reverse('download_report',
kwargs={
'type': 'rcsv',
'year': '2014',
'unit_type': 'dept'
}))
self.assertEqual(response.status_code, 404)
def test_add_RED_FLAG_review(self):
self.card.content_item.topic_needs_review = True
self.card.content_item.save()
self.card.start_topic()
self.card.finish_topic()
self.assertEqual(self.card.status, AgileCard.IN_REVIEW)
review = TopicReview.objects.create(
status=RED_FLAG,
topic_progress=self.card.topic_progress,
reviewer_user=UserFactory(),
)
self.card.refresh_from_db()
self.assertEqual(self.card.status, AgileCard.REVIEW_FEEDBACK)
def fill_db(self, range):
for i in range:
u = UserFactory.create()
u.profile.rrhh_code = i
u.profile.save()
a = Articulo(titulo="ArtName" + str(i),
fecha=datetime.date(randint(2012, 2014), 1, 1))
a.save()
a.user_profile.add(u.profile)
a = Capitulo(titulo="CapName" + str(i),
fecha=datetime.date(randint(2012, 2014), 1, 1))
a.save()
a.user_profile.add(u.profile)
a = Libro(titulo="LibName" + str(i),
fecha=datetime.date(randint(2012, 2014), 1, 1))
a.save()
a.user_profile.add(u.profile)
a = Congreso(titulo="ConName" + str(i),
fecha_de_inicio=datetime.date(randint(2012, 2014), 1,
1))
a.save()
a.user_profile.add(u.profile)
a = Convenio(titulo="ConvName" + str(i),
fecha_de_inicio=datetime.date(randint(2012, 2014), 1,
1))
a.save()
a.user_profile.add(u.profile)
a = Patente(titulo="PatName" + str(i),
fecha=datetime.date(randint(2012, 2014), 1, 1))
a.save()
a.user_profile.add(u.profile)
a = Proyecto(titulo="ProName" + str(i),
fecha_de_inicio=datetime.date(randint(2012, 2014), 1,
1))
a.save()
a.user_profile.add(u.profile)
a = TesisDoctoral(titulo="TesisName" + str(i),
fecha=datetime.date(randint(2012, 2014), 1, 1))
a.save()
a.user_profile.add(u.profile)
def test_is_authenticated_refresh_required(self):
""" Test our custom User.is_authenticated property. """
# create past
past = timezone.now() - timezone.timedelta(days=1)
# create a user who token has expired
user_with_tokens = UserFactory.create(
username='******', email='*****@*****.**', access_token='1',
refresh_token='2', token_expiry=past)
# adding this because of random No route to host errors
with mock.patch(
'accounts.models.OAuth2Credentials') as mock_oauth:
mock_oauth.return_value = MockCredentials(access_token='foo')
self.assertTrue(user_with_tokens.is_authenticated)
def test_daily_norms_calculation_hemodialysis(self):
user = UserFactory()
profile = UserProfile(user=user,
dialysis=DialysisType.Hemodialysis,
date_of_birth=date(1960, 1, 1),
height_cm=180,
diabetes_type=DiabetesType.Type1)
calculator = AdultDailyNormsCalculator(profile, urine_ml=123)
self.assertEqual(calculator.calculate_potassium_mg(), 3123)
self.assertEqual(calculator.calculate_proteins_mg(), 93677)
self.assertEqual(calculator.calculate_sodium_mg(), 2300)
self.assertEqual(calculator.calculate_phosphorus_mg(), 1000)
self.assertIsNone(calculator.calculate_energy_kcal())
self.assertEqual(calculator.calculate_liquids_g(), 1123)
