def verbose_instance_factory(self):
project = factories.RecruitProjectFactory(
due_time=datetime.now(), review_request_time=datetime.now())
card = factories.AgileCardFactory(recruit_project=project)
card.reviewers.add(core_factories.UserFactory())
card.assignees.add(core_factories.UserFactory())
return card
def test_bid_belong_to_user(self):
creator = factories.UserFactory()
bid = factories.BidFactory(creator=creator)
self.assertTrue(bid.belong_to_user(creator))
hacker = factories.UserFactory(username='******')
self.assertFalse(bid.belong_to_user(hacker))
def verbose_instance_factory(self):
project = factories.RecruitProjectFactory()
card = factories.AgileCardFactory(recruit_project=project)
card.reviewers.add(core_factories.UserFactory())
card.assignees.add(core_factories.UserFactory())
card.flavours.add(Tag.objects.create(name="asdsasa"))
return card
def test_review_failed_then_rerequested_flow(self):
card = self.ip_card
untrusted_user = core_factories.UserFactory(
is_staff=False
) # TODO: trust different people for diferent reasons
trusted_user = core_factories.UserFactory(
is_staff=True
) # TODO: trust different people for diferent reasons
project = card.recruit_project
project.start_time = timezone.now() - timedelta(days=15)
project.request_review()
card.refresh_from_db()
project.refresh_from_db()
self.assertEqual(card.status, models.AgileCard.IN_REVIEW)
# add NCY review
factories.RecruitProjectReviewFactory(
recruit_project=project,
reviewer_user=untrusted_user,
status=NOT_YET_COMPETENT,
)
card.refresh_from_db()
project.refresh_from_db()
self.assertEqual(card.status, models.AgileCard.REVIEW_FEEDBACK)
# the recruit asks for another review...
project.request_review()
card.refresh_from_db()
project.refresh_from_db()
self.assertEqual(card.status, models.AgileCard.IN_REVIEW)
# a staff member add a review
factories.RecruitProjectReviewFactory(
recruit_project=project,
reviewer_user=trusted_user,
status=NOT_YET_COMPETENT,
)
card.refresh_from_db()
project.refresh_from_db()
self.assertEqual(card.status, models.AgileCard.REVIEW_FEEDBACK)
# the recruit asks for another review...
project.request_review()
card.refresh_from_db()
project.refresh_from_db()
self.assertEqual(card.status, models.AgileCard.IN_REVIEW)
def test_admin_get_every_bids(self):
factories.BidFactory.create(
title='bid 1',
status_bid=StatusBids.ONHOLD,
creator=factories.UserFactory(is_public_member=True))
factories.BidFactory(
title='bid 2',
status_bid=StatusBids.RUNNING,
creator=factories.UserFactory(is_public_member=False))
response = self.client.get('/api/bids/')
self.assertEquals(200, response.status_code)
bids = json.loads(response.content.decode('utf-8'))['bids']
self.assertEquals(len(bids), 2)
def test_bid_factory(self):
creator = factories.UserFactory(username='******')
bid = factories.BidFactory(creator=creator)
self.assertEquals('Annonce de test', bid.title)
self.assertEquals(creator, bid.creator)
self.assertEquals("factory d'une annonce", bid.description)
self.assertEquals('Jean Dupont', bid.real_author)
def verbose_instance_factory(self):
project = factories.RecruitProjectFactory(
content_item=factories.ProjectContentItemFactory(
project_submission_type=ContentItem.REPOSITORY, ))
factories.RecruitProjectReviewFactory(recruit_project=project)
project.reviewer_users.add(core_factories.UserFactory())
factories.AgileCardFactory(recruit_project=project)
return project
def test_add_members_to_an_association(self):
association = factories.AssociationFactory(administrator=self.user)
self.assertEqual(len(association.members.all()), 0)
new_user = factories.UserFactory(username='******')
response = self.client.post('/api/associations/%s/members/%s/' %
(association.id, new_user.id))
self.assertEqual(201, response.status_code)
association_updated = Association.objects.get(id=association.id)
self.assertEqual(len(association_updated.members.all()), 1)
def setUp(self):
self.trusted_user = core_factories.UserFactory(
is_staff=True) # TODO: trust different people for diferent reasons
self.untrusted_user = core_factories.UserFactory(
is_staff=False
) # TODO: trust different people for diferent reasons
self.ready_card = factories.AgileCardFactory(
status=models.AgileCard.READY)
self.ip_card = factories.AgileCardFactory(
status=models.AgileCard.IN_PROGRESS)
self.feedback_card = factories.AgileCardFactory(
status=models.AgileCard.REVIEW_FEEDBACK)
self.cards = [
self.ready_card,
self.ip_card,
self.feedback_card,
]
def verbose_instance_factory(self):
project = factories.RecruitProjectFactory()
card = factories.AgileCardFactory(recruit_project=project)
card.reviewers.add(core_factories.UserFactory())
card.assignees.add(core_factories.UserFactory())
card.flavours.add(Tag.objects.create(name="asdsasa"))
project.review_request_time = timezone.now() - timedelta(days=5)
project.save()
review = factories.RecruitProjectReviewFactory(
status=NOT_YET_COMPETENT,
recruit_project=project,
)
review.timestamp = timezone.now() - timedelta(days=1)
review.save()
PullRequestFactory(repository=project.repository)
return card
def setUp(self):
self.javascript = Tag.objects.get_or_create(name=JAVASCRIPT)[0]
self.python = Tag.objects.get_or_create(name=PYTHON)[0]
self.content_item = factories.ContentItemFactory()
models.ContentAvailableFlavour.objects.create(
content_item=self.content_item, tag=self.javascript)
models.ContentAvailableFlavour.objects.create(
content_item=self.content_item, tag=self.python)
self.user = core_factories.UserFactory()
def setUp(self):
# self.team_membership = core_factories.TeamMembershipFactory()
# self.recruit = self.team_membership.user
self.recruit = core_factories.UserFactory()
# self.curriculum = self.team_membership.cohort.cohort_curriculum
self.content_item = factories.ContentItemFactory()
self.card = factories.AgileCardFactory(
status=models.AgileCard.READY,
# assignees=[self.recruit],
content_item=self.content_item,
)
self.card.assignees.add(self.recruit)
def setUp(self):
self.blue_team = core_factories.TeamFactory(name="BLUE TEAM")
self.red_team = core_factories.TeamFactory(name="RED TEAM")
self.user_one_blue = core_factories.UserFactory(first_name="one_blue",
is_superuser=False,
is_staff=False)
self.user_two_blue = core_factories.UserFactory(first_name="two_blue",
is_superuser=False,
is_staff=False)
self.user_one_red = core_factories.UserFactory(first_name="one_red",
is_superuser=False,
is_staff=False)
self.user_two_red = core_factories.UserFactory(first_name="two_red",
is_superuser=False,
is_staff=False)
self.super_user = core_factories.UserFactory(first_name="super_user",
is_superuser=True)
self.blue_team.user_set.add(self.user_one_blue)
self.blue_team.user_set.add(self.user_two_blue)
self.red_team.user_set.add(self.user_one_red)
self.red_team.user_set.add(self.user_two_red)
def setUp(self):
self.trusted_user = core_factories.UserFactory()
self.untrusted_user = core_factories.UserFactory()
self.ready_card = factories.AgileCardFactory(status=models.AgileCard.READY)
self.ip_card = factories.AgileCardFactory(status=models.AgileCard.IN_PROGRESS)
self.feedback_card = factories.AgileCardFactory(
status=models.AgileCard.REVIEW_FEEDBACK
)
self.cards = [
self.ready_card,
self.ip_card,
self.feedback_card,
]
for card in self.cards:
factories.ReviewTrustFactory(
content_item = card.content_item,
user=self.trusted_user,
flavours = card.recruit_project.flavour_names
)
assert card.recruit_project.is_trusted_reviewer(self.trusted_user)
def test_association_to_json_method(self):
user = factories.UserFactory()
self.client.login(username=user.username, password="******")
association = factories.AssociationFactory(name="toto")
expected_association = {
'id': association.id,
'name': association.name,
'address': association.address,
'phone': association.phone,
'url_site': association.url_site,
'email': association.email,
'administrator': association.administrator.serialize()
}
self.assertDictEqual(association.serialize(), expected_association)
def test_get_bids_return_every_running_bids_or_own_bids(self):
factories.BidFactory.create(
title='bid 1',
status_bid=StatusBids.ONHOLD,
creator=factories.UserFactory(is_public_member=True))
factories.BidFactory(title='bid 2',
status_bid=StatusBids.ONHOLD,
creator=self.user)
factories.BidFactory(title='bid 3',
status_bid=StatusBids.RUNNING,
creator=self.user)
response = self.client.get('/api/bids/')
self.assertEquals(200, response.status_code)
bids = json.loads(response.content.decode('utf-8'))['bids']
self.assertEquals(len(bids), 2)
self.assertEquals(bids[0]['title'], 'bid 2')
def test_that_user_given_permission_trusted_reviewer_makes_trusted_review(
self):
user = core_factories.UserFactory()
recruit_team = core_factories.TeamFactory()
assign_perm(Team.PERMISSION_TRUSTED_REVIEWER, user, recruit_team)
untrusted = factories.RecruitProjectReviewFactory(
reviewer_user=user, recruit_project=self.ip_card.recruit_project)
self.assertFalse(untrusted.trusted)
# now add the recruit to the team and make another review
recruit_team.user_set.set(
self.ip_card.recruit_project.recruit_users.all())
trusted = factories.RecruitProjectReviewFactory(
reviewer_user=user, recruit_project=self.ip_card.recruit_project)
self.assertTrue(trusted.trusted)
self.assertFalse(untrusted.trusted)
def test_bid_to_json_method(self):
self.maxDiff = None
user = factories.UserFactory()
self.client.login(username=user.username, password="******")
bid = factories.BidFactory(creator=user)
expected_bid = {
'begin': None,
'quantity': None,
'end': None,
'id': bid.id,
'title': 'Annonce de test',
'creator': user.username,
'description': bid.description,
'category': None,
'type': 'SUPPLY',
'real_author': 'Jean Dupont',
'localization': None,
'status_bid': StatusBids.RUNNING,
'unit': None,
'association': None,
'photo': None
}
self.assertEquals(bid.serialize(), expected_bid)
def setUp(self):
self.user = core_factories.UserFactory()
def setUp(self):
self.user = factories.UserFactory()
self.client.login(username=self.user.username, password="******")
def setUp(self):
self.active_team = factories.TeamFactory()
self.inactive_team = factories.TeamFactory(active=False)
self.user = factories.UserFactory()
self.active_team.users.add(self.user)
self.inactive_team.users.add(self.user)
def setUp(self):
self.user = factories.UserFactory(is_staff=True)
self.client.login(username=self.user.username, password="******")
self.maxDiff = None
def test_that_superuser_always_trusted(self):
superuser = core_factories.UserFactory(is_superuser=True)
review = factories.RecruitProjectReviewFactory(
reviewer_user=superuser,
recruit_project=self.ip_card.recruit_project)
self.assertTrue(review.trusted)
def setUp(self):
self.creator = factories.UserFactory()
def setUp(self):
self.user = factories.UserFactory(is_public_member=True)
self.client.login(username=self.user.username, password="******")
def test_create_super_user(self):
user = factories.UserFactory(username='******', is_superuser=True)
self.assertTrue(isinstance(user, User))
self.assertEquals(user.email, '*****@*****.**')
self.assertTrue(user.is_superuser)
def test_user_factory_is_authenticated(self):
user = factories.UserFactory()
is_authenticated = self.client.login(username=user.username,
password="******")
self.assertTrue(is_authenticated)
def test_user_factory(self):
user = factories.UserFactory()
self.assertTrue(isinstance(user, User))
self.assertEquals(user.email, '*****@*****.**')
