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') ]