def test_views(self):
client = Client()
user = UserFactory.create(username='******', password='******')
client.login(username=user.username, password='******')
now = datetime.datetime.now(pytz.UTC)
tomorrow = datetime.datetime.now(pytz.UTC) + datetime.timedelta(days=1, )
response = client.get(reverse('index'))
self.assertEqual(200,response.status_code)
response = client.get(reverse('passed'))
self.assertEqual(200,response.status_code)
active_not_drawn = LotteryFactory.create(is_active=True, is_closed_from=tomorrow, is_active_from=now)
response = client.get(reverse('entry', args=(active_not_drawn.pk,)))
self.assertEqual(200,response.status_code)
post_var = {}
balls = range(1, int(active_not_drawn.max_ball))
i = 1
while len(post_var.values()) < active_not_drawn.number_of_balls:
post_var['%s%s' % (BALL_KEY,i)] = balls.pop(random.randrange(len(balls)))
i += 1
print post_var
client.post(reverse('entry', args=(active_not_drawn.pk,)), post_var)
self.assertIn(active_not_drawn.pk, Entry.objects.filter(entry_user=user).values_list('pk',flat=True))
response = client.get(reverse('user_index'))
self.assertEqual(200,response.status_code)
def handle(self, *args, **options):
self.stdout.write(self.style.WARNING('All users created with password - password'))
# CREATE USERS
# create admin user
UserFactory.create(username='******', is_superuser=True, is_staff=True)
self.stdout.write(self.style.SUCCESS('Superuser username: super'))
staff_user = UserFactory.create(username='******', is_superuser=False, is_staff=True)
# give the admin user everything for the purpose of testing
staff_user.user_permissions.add(*list(Permission.objects.all()))
self.stdout.write(self.style.SUCCESS('Staff username: Admin'))
# create 100 standard users
UserFactory.create_batch(30)
self.stdout.write(self.style.SUCCESS('100 Random users created'))
# CREATE LOTTOS
# create random
LotteryFactory.create_batch(2, is_active=True)
# create some random active 3 ball lotteries
LotteryFactory.create_batch(5, number_of_balls=3, is_active=True)
# create some random active 6 ball lotteries
LotteryFactory.create_batch(5, number_of_balls=6, is_active=True)
# create some inactive
LotteryFactory.create_batch(5, number_of_balls=3, is_active=False)
self.stdout.write(self.style.SUCCESS('Test data created!'))
# CREATE ENTRIES
lottos = Lottery.objects.filter()
EntryFactory.create_batch(100, entry_for=lottos[0])
EntryFactory.create_batch(100, entry_for=lottos[1])
EntryFactory.create_batch(100, entry_for=lottos[2])
# draw some lottos
lottos[0].do_draw(machine='arthur')
lottos[1].do_draw(machine='guinevere')
lottos[2].do_draw(machine='cheat')
def seed_comments(review):
for i in range(randint(0, 5)):
comm_user = None
if random() > 0.1:
comm_user = users[randint(0, len(users) - 1)]
else:
comm_user = UserFactory()
users.append(comm_user)
CommentFactory(review=review, user=comm_user)
def test_set_up_coordinator_B(mock_api):
"""Check service function adds User who is not already a Group member."""
user = UserFactory()
mock_api.group.members.return_value = []
set_up_coordinator(user)
mock_api.group.members.assert_called_once()
mock_api.group.add_user.assert_called_once_with(user.email)
def test_add_user_to_case(mock_api):
"""Check service function gives user write permissions to existing case folder."""
user = UserFactory()
issue = IssueFactory()
add_user_to_case(user, issue)
mock_api.folder.create_permissions.assert_called_once_with(
f"cases/{issue.id}", "write", [user.email])
def test_set_up_coordinator_A(mock_api):
"""Check service function doesn't add User who is already a Group member."""
user = UserFactory()
mock_api.group.members.return_value = [user.email]
set_up_coordinator(user)
mock_api.group.members.assert_called_once()
mock_api.group.add_user.assert_not_called()
def setUpTestData(cls):
cls.user = UserFactory()
cls.projeto = ProjetoFactory(name='Projeto 1', created_by=cls.user)
cls.naver_projetos = dict(
naver_1=NaverProjetoFactory(
projeto=cls.projeto,
naver__name='José Souza',
naver__birthdate='1991-02-01',
naver__admission_date='2019-03-01',
naver__job_role='Desenvolvedor BackEnd',
naver__created_by=cls.user),
naver_2=NaverProjetoFactory(
projeto=cls.projeto,
naver__name='Maria Fernanda',
naver__birthdate='1993-01-08',
naver__admission_date='2019-04-02',
naver__job_role='Desenvolvedor FrontEnd',
naver__created_by=cls.user),
naver_3=NaverProjetoFactory(projeto=cls.projeto,
naver__name='Marina Alves',
naver__birthdate='1989-01-01',
naver__admission_date='2018-05-07',
naver__job_role='Tester',
naver__created_by=cls.user),
naver_4=NaverProjetoFactory(projeto=cls.projeto,
naver__name='Magno Oliveira',
naver__birthdate='1994-10-02',
naver__admission_date='2020-05-01',
naver__job_role='Gerente de Projetos',
naver__created_by=cls.user))
cls.expected_naver_show_response = dict(
id=1,
name='Projeto 1',
navers=[
dict(id=1,
name='José Souza',
birthdate='1991-02-01',
admission_date='2019-03-01',
job_role='Desenvolvedor BackEnd'),
dict(id=2,
name='Maria Fernanda',
birthdate='1993-01-08',
admission_date='2019-04-02',
job_role='Desenvolvedor FrontEnd'),
dict(id=3,
name='Marina Alves',
birthdate='1989-01-01',
admission_date='2018-05-07',
job_role='Tester'),
dict(id=4,
name='Magno Oliveira',
birthdate='1994-10-02',
admission_date='2020-05-01',
job_role='Gerente de Projetos'),
])
def setUpTestData(cls):
cls.user = UserFactory()
cls.naver_1 = NaverFactory(
name='Rodrigo',
created_by=cls.user
)
cls.naver_2 = NaverFactory(
name='Marcela',
created_by=cls.user
)
def setUpTestData(cls):
cls.user = UserFactory()
cls.other_user = UserFactory()
cls.own_naver = NaverFactory(name='Joao Augusto',
birthdate='1990-10-12',
admission_date='2018-01-02',
job_role='Desenvolvedor React',
created_by=cls.user)
cls.naver_new_data = dict(name='João Augusto Oliveira',
birthdate='1991-10-12',
admission_date='2018-01-03',
job_role='Desenvolvedor FrontEnd',
created_by=cls.user)
cls.others_naver = NaverFactory(created_by=cls.other_user)
cls.others_naver_new_data = dict(name='João Augusto Oliveira',
birthdate='1991-10-12',
admission_date='2018-01-03',
job_role='Desenvolvedor FrontEnd',
created_by=cls.user)
def setUpTestData(cls):
cls.user = UserFactory(email='*****@*****.**')
cls.naver = NaverFactory(name='John Doe',
birthdate=parse_date('1990-10-12'),
admission_date=parse_date('2011-08-01'),
job_role='Desenvolvedor',
created_by=cls.user)
cls.projeto = ProjetoFactory(name='Any project', created_by=cls.user)
cls.naver_projeto = NaverProjetoFactory(projeto=cls.projeto,
naver=cls.naver)
def test_calculate_one_activity(self):
project = ProjectFactory()
user = UserFactory()
activity_journal = ActivityJournal.objects.create(project=project,
user=user,
time_lapse=10)
total_time = project.time_calculator(user=user)
self.assertEqual(str(dt.timedelta(seconds=10)), total_time)
def test_tear_down_coordinator_B(mock_api):
"""Check service function doesn't remove User who is not already a Group member."""
user = UserFactory()
mock_api.group.members.return_value = []
tear_down_coordinator(user)
mock_api.group.members.assert_called_once()
mock_api.user.get.assert_not_called()
mock_api.group.remove_user.assert_not_called()
def setUpClass(cls): super().setUpClass() MarketFactory( start_date=timezone.datetime(2050, 5, 1, 0, 0, 0, tzinfo=utc), end_date=timezone.datetime(2050, 9, 30, 23, 59, 59, tzinfo=utc), weight=2, alpha=2, slug='guess-my-ssn' ) UserFactory(username='******')
def test_is_teacher_permissions(self):
user = UserFactory(is_teacher=True)
password = fuzzy.FuzzyText().fuzz()
user.set_password(password)
user.save()
key = self.client.post(reverse('api_auth_login_api_view'), data={
'username': user.username,
'password': password
}).json()['key']
queue = QueueFactory(creator=self.user)
for token in (self._get_auth_header(key), self.access_header):
res = self.client.put(
reverse(
'api_queue_add_member_api_view',
kwargs={'pk': str(queue.id)}
),
data={'userId': str(user.id)}, content_type='application/json',
HTTP_AUTHORIZATION=token
)
self.assertEqual(res.status_code, status.HTTP_403_FORBIDDEN)
user_1, user_2 = UserFactory(), UserFactory()
queue.push_member(str(user_1.id))
queue.push_member(str(user_2.id))
queue.save()
queue.refresh_from_db()
self.assertEqual(queue.members, [str(user_2.id), str(user_1.id)])
res = self.client.put(
reverse('api_queue_skip_turn_api_view', kwargs={'pk': str(queue.id)}),
data={
'userId': str(user_1.id)
},
content_type='application/json',
HTTP_AUTHORIZATION=self._get_auth_header(key)
)
self.assertEqual(res.status_code, status.HTTP_200_OK)
queue.refresh_from_db()
self.assertEqual(queue.members, [str(user_1.id), str(user_2.id)])
res = self.client.put(
reverse(
'api_queue_remove_member_api_view',
kwargs={'pk': str(queue.id)}
), data={'userId': str(user_2.id)}, content_type='application/json',
HTTP_AUTHORIZATION=self._get_auth_header(key)
)
self.assertEqual(res.status_code, status.HTTP_200_OK)
queue.refresh_from_db()
self.assertEqual(queue.members, [str(user_1.id)])
def test_tear_down_coordinator_A(mock_api):
"""Check service function removes User who is already a Group member."""
user = UserFactory()
mock_api.group.members.return_value = [user.email]
mock_api.user.get.return_value = {"id": user.id}
tear_down_coordinator(user)
mock_api.group.members.assert_called_once()
mock_api.user.get.assert_called_once_with(user.email)
mock_api.group.remove_user.assert_called_once_with(user.id)
def setUpTestData(cls):
cls.user = UserFactory()
cls.projetos_dict = dict(projeto_1=ProjetoFactory(name='Projeto 1',
created_by=cls.user),
projeto_2=ProjetoFactory(name='Projeto 2',
created_by=cls.user))
cls.expected_projects_list = [
dict(id=1, name='Projeto 1'),
dict(id=2, name='Projeto 2'),
]
def test_remove_user_from_case_A(mock_api):
"""Check service function when there are no permissions on the case folder."""
user = UserFactory()
issue = IssueFactory()
mock_api.folder.list_permissions.return_value = None
remove_user_from_case(user, issue)
mock_api.folder.list_permissions.assert_called_once_with(
f"cases/{issue.id}")
mock_api.folder.delete_permission.assert_not_called()
def test_admin_to_coordinator(
tear_down_coordinator, set_up_coordinator, remove_user_from_case
):
user = UserFactory()
admin_group = Group.objects.get(name=CaseGroups.ADMIN)
coordinator_group = Group.objects.get(name=CaseGroups.COORDINATOR)
user.groups.add(admin_group)
user.groups.add(coordinator_group)
tear_down_coordinator.assert_not_called()
user.groups.remove(admin_group)
tear_down_coordinator.assert_not_called()
def setUpTestData(cls):
user = UserFactory()
with freeze_time(cls.too_old):
cls.url_item = cls._create_item(user, url='http://kodziek.pl')
with freeze_time(cls.almost_too_old):
cls.file_item = cls.file_url = cls._create_item(
user,
file=SimpleUploadedFile('file', b'content'),
)
with freeze_time(cls.today):
cls._create_item(user)
def test_set_up_new_user_A(mock_api):
"""Check service function does not create MS account or assign license for existing user."""
user = UserFactory()
mock_api.user.get.return_value = {
f"Microsoft Account already exists for {user.email}"
}
set_up_new_user(user)
mock_api.user.get.assert_called_once_with(user.email)
mock_api.user.create.assert_not_called()
mock_api.user.assign_license.assert_not_called()
def test_queue_members_operations(self):
creator = UserFactory()
users = UserFactory.create_batch(2)
queue = Queue(name='abc', creator=creator)
queue.save()
self.assertEqual(queue.members, [])
queue.push_member(str(users[0].id))
queue.save()
queue.refresh_from_db()
self.assertEqual(queue.members, [str(users[0].id)])
queue.pop_member(str(users[1].id))
queue.save()
queue.refresh_from_db()
self.assertEqual(queue.members, [str(users[0].id)])
queue.pop_member(str(users[0].id))
queue.save()
queue.refresh_from_db()
self.assertEqual(queue.members, [])
def test_logout(client):
"""
Ensure URLs return the correct status code.
"""
user = UserFactory()
client.force_login(user)
assert user.is_authenticated
resp = client.get(reverse("logout"))
# Redirects back to login page
assert resp.status_code == 302
assert resp.url == reverse("login")
# Sets session ID to empty string
resp.cookies["sessionid"].value == ""
def test_set_up_new_user_B(mock_api):
"""Check service function creates MS account and assigns license for new user."""
user = UserFactory()
mock_api.user.get.return_value = None
mock_api.user.create.return_value = user, "open sesame"
password = set_up_new_user(user)
mock_api.user.get.assert_called_once_with(user.email)
mock_api.user.create.assert_called_once_with(user.first_name,
user.last_name, user.email)
mock_api.user.assign_license.assert_called_once_with(user.email)
assert password == "open sesame"
def seed_reviews(product):
poss_users = users.copy()
for i in range(randint(0, 30)):
review_user = None
if random() > 0.1 and len(poss_users) > 0:
index = randint(0, len(poss_users) - 1)
review_user = poss_users[index]
del poss_users[index]
else:
review_user = UserFactory()
users.append(review_user)
review = ReviewFactory(product=product, user=review_user)
seed_comments(review)
def test_permissions(self):
another_user = UserFactory()
password = fuzzy.FuzzyText().fuzz()
another_user.set_password(password)
another_user.save()
response = self.client.delete(self._get_url(another_user.id),
HTTP_AUTHORIZATION=self.access_header)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def handle(self, *args, **options):
# Creates an admin with the credentials `admin // admin`
admin = AdminFactory()
user = UserFactory()
# Creates a first project with admin as an admin
project = ProjectFactory()
ProjectMemberRoleFactory(user=admin, project=project)
ProjectMemberRoleFactory(user=user, project=project, is_admin=False)
parameters_project = ProjectAuditParametersFactory(project=project)
parameters2_project = ProjectAuditParametersFactory(
project=project,
name="Dulles | Chrome | 3G",
network_shape=NetworkShapeOptions.THREE_G.name,
)
page = PageFactory(project=project)
page2 = PageFactory(project=project, name="Docs")
# Creates a month worth of audits, with history and results
for day in range(0, 30):
audit = AuditFactory(parameters=parameters_project, page=page)
timestamp = datetime.now(
pytz.timezone("Europe/Paris")) - timedelta(days=day)
Audit.objects.filter(pk=audit.pk).update(created_at=timestamp)
AuditStatusHistoryFactory(audit=audit)
results = AuditResultsFactory(audit=audit)
AuditResults.objects.filter(pk=results.pk).update(
created_at=timestamp)
audit2 = AuditFactory(parameters=parameters2_project, page=page)
Audit.objects.filter(pk=audit2.pk).update(created_at=timestamp)
AuditStatusHistoryFactory(audit=audit2)
results2 = AuditResultsFactory(audit=audit2)
AuditResults.objects.filter(pk=results2.pk).update(
created_at=timestamp)
audit3 = AuditFactory(parameters=parameters_project, page=page2)
Audit.objects.filter(pk=audit3.pk).update(created_at=timestamp)
AuditStatusHistoryFactory(audit=audit3)
results3 = AuditResultsFactory(audit=audit3)
AuditResults.objects.filter(pk=results3.pk).update(
created_at=timestamp)
audit4 = AuditFactory(parameters=parameters2_project, page=page2)
Audit.objects.filter(pk=audit4.pk).update(created_at=timestamp)
AuditStatusHistoryFactory(audit=audit4)
results4 = AuditResultsFactory(audit=audit4)
AuditResults.objects.filter(pk=results4.pk).update(
created_at=timestamp)
def test_remove_user_from_case_B(mock_api):
"""Check service function when there are permissions on the case folder that don't belong to our user."""
user = UserFactory(email="*****@*****.**")
issue = IssueFactory()
mock_api.folder.list_permissions.return_value = [("666", {
"user": {
"email": "*****@*****.**"
}
})]
remove_user_from_case(user, issue)
mock_api.folder.list_permissions.assert_called_once_with(
f"cases/{issue.id}")
mock_api.folder.delete_permission.assert_not_called()
def test_remove_paralegal_from_group(
core_add_user_to_case,
core_remove_user_from_case,
accounts_tear_down_coordinator,
accounts_set_up_coordinator,
accounts_remove_user_from_case,
):
user = UserFactory()
group = Group.objects.get(name=CaseGroups.PARALEGAL)
user.groups.add(group)
issue = IssueFactory(is_case_sent=True, paralegal=user)
accounts_remove_user_from_case.assert_not_called()
user.groups.remove(group)
accounts_remove_user_from_case.assert_called_once_with(user, issue)
def test_entry(self):
user = UserFactory.create()
now = datetime.datetime.now(pytz.UTC)
tomorrow = datetime.datetime.now(pytz.UTC) + datetime.timedelta(days=1, )
active_not_drawn = LotteryFactory.create(is_active=True, is_closed_from=tomorrow, is_active_from=now)
entry = EntryFactory.create(entry_for=active_not_drawn, entry_user=user)
self.assertEqual(None, entry.winner)
# test the cheat draw , should pick entry as its the only one!
active_not_drawn.do_draw(machine='cheat')
print '**%s' % entry.balls
print '##%s' % active_not_drawn.draw_result
self.assertEqual(True, Entry.objects.get(id=entry.pk).winner)
def setUpTestData(cls):
cls.user = UserFactory()
cls.file_content = b'content'
cls.password = '******'
cls.password_encrypted = make_password(cls.password)
with freeze_time(datetime.now() - settings.ITEMS_LIFETIME):
cls.old_item = ItemFactory(
user=cls.user,
url=reverse('login'),
password=cls.password_encrypted,
)
cls.old_item_url = reverse(
'items:get',
kwargs={'uuid': cls.old_item.uuid},
)
def test_member_operations(self):
queue = QueueFactory(creator=self.user)
count = 3
users = UserFactory.create_batch(count)
for user in users:
res = self.client.put(
reverse(
'api_queue_add_member_api_view',
kwargs={'pk': str(queue.id)}
),
data={'userId': str(user.id)}, content_type='application/json',
HTTP_AUTHORIZATION=self.access_header
)
self.assertEqual(res.status_code, status.HTTP_200_OK)
queue.refresh_from_db()
self.assertEqual(queue.members, list(map(lambda x: str(x.id), users[::-1])))
for user in users:
res = self.client.put(
reverse(
'api_queue_move_member_to_end_api_view',
kwargs={'pk': str(queue.id)}
), data={'userId': str(user.id)}, content_type='application/json',
HTTP_AUTHORIZATION=self.access_header
)
self.assertEqual(res.status_code, status.HTTP_200_OK)
queue.refresh_from_db()
self.assertEqual(queue.members[0], str(user.id))
queue.refresh_from_db()
self.assertEqual(queue.members, list(map(lambda x: str(x.id), users[::-1])))
queue.refresh_from_db()
self.assertEqual(queue.members, list(map(lambda x: str(x.id), users[::-1])))
for i in range(count):
user = users[i]
res = self.client.put(
reverse(
'api_queue_remove_member_api_view',
kwargs={'pk': str(queue.id)}
), data={'userId': str(user.id)}, content_type='application/json',
HTTP_AUTHORIZATION=self.access_header
)
self.assertEqual(res.status_code, status.HTTP_200_OK)
queue.refresh_from_db()
self.assertEqual(len(queue.members), count - i - 1)
def test_failed_auth(self):
user = UserFactory()
user.set_password(fuzzy.FuzzyText().fuzz())
user.save()
response = self.client.post(reverse('api_auth_login_api_view'),
data={
'username': user.username,
'password': fuzzy.FuzzyText().fuzz()
})
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
def setUpTestData(cls):
cls.user = UserFactory()
cls.navers_dict = dict(
naver_1=NaverFactory(name="Joao Augusto",
birthdate=parse_date('1990-10-12'),
admission_date=parse_date('2018-01-02'),
job_role='Desenvolvedor React',
created_by=cls.user),
naver_2=NaverFactory(name='Fernanda Oliveira',
birthdate=parse_date('1995-08-06'),
admission_date=parse_date('2019-05-03'),
job_role='Desenvolvedora Backend',
created_by=cls.user),
naver_3=NaverFactory(name='Deivison Pereira',
birthdate=parse_date('1999-02-03'),
admission_date=parse_date('2020-01-04'),
job_role='Estagiário Teste',
created_by=cls.user),
naver_4=NaverFactory(name='Priscila Marques',
birthdate=parse_date('1987-01-23'),
admission_date=parse_date('2014-02-02'),
job_role='Gerente de Projetos',
created_by=cls.user))
cls.expected_navers_list = [
dict(id=1,
name='Joao Augusto',
birthdate='1990-10-12',
admission_date='2018-01-02',
job_role='Desenvolvedor React'),
dict(id=2,
name='Fernanda Oliveira',
birthdate='1995-08-06',
admission_date='2019-05-03',
job_role='Desenvolvedora Backend'),
dict(id=3,
name='Deivison Pereira',
birthdate='1999-02-03',
admission_date='2020-01-04',
job_role='Estagiário Teste'),
dict(id=4,
name='Priscila Marques',
birthdate='1987-01-23',
admission_date='2014-02-02',
job_role='Gerente de Projetos')
]
