def test_proposal_can_create_evaluation(self):
proposal = database_population.create_proposal()
# It cannot be evaluated, it's not eligible
self.assertFalse(proposal.can_create_evaluation())
self.assertEqual(
'To evaluate the proposal the status needs to be submitted',
proposal.reason_cannot_create_evaluation())
# Let's make it eligible
proposal.eligibility = Proposal.ELIGIBLE
proposal.save()
# It cannot be evaluated: the proposal status needs to be submitted
self.assertFalse(proposal.can_create_evaluation())
self.assertEqual(
'To evaluate the proposal the status needs to be submitted',
proposal.reason_cannot_create_evaluation())
# Let's mark the proposal as submitted
proposal.proposal_status = ProposalStatus.objects.get(
name=settings.PROPOSAL_STATUS_SUBMITTED)
proposal.save()
# It cannot be evaluated: no call evaluation yet
self.assertFalse(proposal.can_create_evaluation())
self.assertEqual(
'To evaluate the proposal a Call Evaluation needs to be created',
proposal.reason_cannot_create_evaluation())
call_evaluation = CallEvaluation(call=proposal.call,
panel_date=datetime.now())
call_evaluation.save()
self.assertTrue(proposal.can_create_evaluation())
def test_save_permission_denied_call_closed(self):
proposal = create_proposal()
proposal.proposal_status = ProposalStatus.objects.get(
name=settings.PROPOSAL_STATUS_SUBMITTED)
proposal.save()
reviewers = [create_reviewer()]
proposal.call.reviewer_set.add(*reviewers)
data = {
'proposal': proposal,
'allocated_budget': 10_000,
'panel_remarks': 'Very good',
'feedback_to_applicant': 'Keep working on it!',
'panel_recommendation':
ProposalEvaluation.PANEL_RECOMMENDATION_FUND,
'board_decision': ProposalEvaluation.BOARD_DECISION_FUND,
'decision_date': datetime.today(),
'reviewers': reviewers
}
call_evaluation = CallEvaluation()
call_evaluation.panel_date = datetime.today()
call_evaluation.call = proposal.call
call_evaluation.close(database_population.create_management_user())
proposal_evaluation_form = ProposalEvaluationForm(data=data,
proposal=proposal)
self.assertTrue(proposal_evaluation_form.is_valid())
self.assertRaises(PermissionDenied,
proposal_evaluation_form.save,
user=self._user)
self.assertEqual(ProposalEvaluation.objects.count(), 0)
def test_check_eligible_proposals_have_evaluation(self):
proposal = database_population.create_proposal()
proposal.eligibility = Proposal.ELIGIBILITYNOTCHECKED
proposal.proposal_status = ProposalStatus.objects.get(
name=settings.PROPOSAL_STATUS_SUBMITTED)
proposal.save()
proposals = Proposal.objects.filter(uuid=proposal.uuid)
# Expects one proposal that is eligible but doesn't have a proposal evaluation
check_result = CallEvaluationValidation._check_all_submitted_proposals_have_eligibility_set(
proposals)
self.assertEqual(check_result['proposals'].count(), 1)
proposal_evaluation = ProposalEvaluation()
proposal_evaluation.proposal = proposal
proposal_evaluation.save()
proposal.eligibility = Proposal.ELIGIBLE
proposal.save()
proposals = Proposal.objects.filter(uuid=proposal.uuid)
# Now it has the proposal evaluation, it's all good
check_result = CallEvaluationValidation._check_all_submitted_proposals_have_eligibility_set(
proposals)
self.assertEqual(check_result['proposals'].count(), 0)
def setUp(self):
self._user = database_population.create_management_user()
self._proposal = database_population.create_proposal()
self._client_management = database_population.create_management_logged_client(
)
self._reviewer = database_population.create_reviewer()
self._criteria = database_population.create_evaluation_criteria()
def test_save(self):
self.assertEqual(ProposalEvaluation.objects.count(), 0)
proposal = create_proposal()
ProposalEvaluationFormTest._create_call_evaluation(proposal.call)
proposal.proposal_status = ProposalStatus.objects.get(
name=settings.PROPOSAL_STATUS_SUBMITTED)
proposal.save()
reviewers = [create_reviewer()]
proposal.call.reviewer_set.add(*reviewers)
data = {
'proposal': proposal,
'allocated_budget': 10_000,
'panel_remarks': 'Very good',
'feedback_to_applicant': 'Keep working on it!',
'panel_recommendation':
ProposalEvaluation.PANEL_RECOMMENDATION_FUND,
'board_decision': ProposalEvaluation.BOARD_DECISION_FUND,
'decision_date': datetime.today(),
'reviewers': reviewers
}
proposal_evaluation_form = ProposalEvaluationForm(data=data,
proposal=proposal)
self.assertTrue(proposal_evaluation_form.is_valid())
proposal_evaluation_form.save(user=self._user)
self.assertEqual(ProposalEvaluation.objects.count(), 1)
def setUp(self):
self._proposal = database_population.create_proposal()
self._academic_title = database_population.create_academic_title()
self._career_stage = database_population.create_career_stage()
self._organisations = database_population.create_organisation_names()
self._role = database_population.create_roles()[0]
def setUp(self):
self._proposal = database_population.create_proposal()
self._call_evaluation = CallEvaluation()
self._call_evaluation.call = self._proposal.call
self._call_evaluation.panel_date = datetime.today()
self._call_evaluation.save()
self._client_management = database_population.create_management_logged_client(
)
def setUp(self):
self._proposal = database_population.create_proposal()
self._category, _ = Category.objects.get_or_create(name='Budget')
self._proposal_comment_category, _ = ProposalCommentCategory.objects.get_or_create(
category=self._category)
self._proposal_attachment_category, _ = ProposalAttachmentCategory.objects.get_or_create(
category=self._category)
self._user_management = database_population.create_management_logged_client(
)
def test_not_eligible_missing_comment(self):
proposal = create_proposal()
self.assertEqual(proposal.eligibility, Proposal.ELIGIBILITYNOTCHECKED)
data = {'comment': '', 'eligible': 'False'}
eligibility_decision_form = EligibilityDecisionForm(
data=data, proposal_id=proposal.id)
self.assertFalse(eligibility_decision_form.is_valid())
def test_save_permission_denied(self):
proposal = create_proposal()
proposal.proposal_status = ProposalStatus.objects.get(
name=settings.PROPOSAL_STATUS_SUBMITTED)
proposal.save()
data = {
'proposal': proposal,
'allocated_budget': 10_000,
'panel_remarks': 'Very good',
'feedback_to_applicant': 'Keep working on it!',
'panel_recommendation':
ProposalEvaluation.PANEL_RECOMMENDATION_FUND,
'board_decision': ProposalEvaluation.BOARD_DECISION_FUND,
}
def test_proposal_can_eligibility_be_created_or_changed(self):
proposal = database_population.create_proposal()
# Eligibility cannot be created or changed: ProposalStatus is not correct
self.assertFalse(proposal.can_eligibility_be_created_or_changed())
self.assertEqual(
'Proposal status cannot be draft in order to create/edit eligibility',
proposal.reason_eligibility_cannot_be_created_or_changed())
# Let's make the ProposalStatus submitted...
proposal.proposal_status = ProposalStatus.objects.get(
name=settings.PROPOSAL_STATUS_SUBMITTED)
proposal.save()
self.assertTrue(proposal.can_eligibility_be_created_or_changed())
def test_permission_denied(self):
user_not_in_management = User.objects.create_user(
'TestUserNotInManagement', '*****@*****.**',
'password')
proposal = create_proposal()
comment = 'This is a test'
data = {'comment': comment, 'eligible': 'True'}
eligibility_decision_form = EligibilityDecisionForm(
data=data, proposal_id=proposal.id)
self.assertTrue(eligibility_decision_form.is_valid())
self.assertRaises(PermissionDenied,
eligibility_decision_form.save_eligibility,
user_not_in_management)
def test_eligibility(self):
proposal = create_proposal()
self.assertEqual(proposal.eligibility, Proposal.ELIGIBILITYNOTCHECKED)
comment = 'This is a test'
data = {'comment': comment, 'eligible': 'True'}
eligibility_decision_form = EligibilityDecisionForm(
data=data, proposal_id=proposal.id)
self.assertTrue(eligibility_decision_form.is_valid())
eligibility_decision_form.save_eligibility(self._user)
proposal.refresh_from_db()
self.assertEqual(proposal.eligibility, Proposal.ELIGIBLE)
self.assertEqual(proposal.eligibility_comment, comment)
def test_check_all_submitted_proposals_have_eligibility(self):
proposal = database_population.create_proposal()
proposal.eligibility = Proposal.ELIGIBILITYNOTCHECKED
proposal.proposal_status = ProposalStatus.objects.get(
name=settings.PROPOSAL_STATUS_SUBMITTED)
proposal.save()
proposals = Proposal.objects.filter(uuid=proposal.uuid)
# Expects one Proposal that is submitted but eligibility not checked...
check_result = CallEvaluationValidation._check_all_submitted_proposals_have_eligibility_set(
proposals)
self.assertEqual(check_result['proposals'].count(), 1)
self.assertEqual(check_result['proposals'][0], proposal)
# Sets it not eligible
proposal.eligibility = Proposal.NOTELIGIBLE
proposal.save()
# Then all good for this test
check_result = CallEvaluationValidation._check_all_submitted_proposals_have_eligibility_set(
proposals)
self.assertEqual(check_result['proposals'].count(), 0)
def setUp(self):
self._proposal = database_population.create_proposal()
self._keywords = database_population.create_keywords()
def setUp(self):
self._proposal = database_population.create_proposal()
self._client_management = database_population.create_management_logged_client(
)
def setUp(self):
category, _ = Category.objects.get_or_create(name='Correspondence')
self._proposal_attachment_category, _ = ProposalAttachmentCategory.objects.get_or_create(
category=category)
self._proposal = database_population.create_proposal()
def setUp(self):
self._proposal = database_population.create_proposal()
def setUp(self):
self._proposal = database_population.create_proposal()
self._client_management = database_population.create_management_logged_client()
create_default_template_variables()
def setUp(self):
self._budget_categories = database_population.create_budget_categories(
)
self._proposal = database_population.create_proposal()
