def setUpTestData(cls):
cls.unicef_staff = UserFactory(is_staff=True)
partner = PartnerFactory(
partner_type='Government',
vendor_number='Vendor No',
short_name="Short Name",
alternate_name="Alternate Name",
shared_with=["DPKO", "ECA"],
address="Address 123",
phone_number="Phone no 1234567",
email="*****@*****.**",
rating="High",
core_values_assessment_date=datetime.date.today(),
total_ct_cp=10000,
total_ct_cy=20000,
deleted_flag=False,
blocked=False,
type_of_assessment="Type of Assessment",
last_assessment_date=datetime.date.today(),
)
partnerstaff = PartnerStaffFactory(partner=partner)
agreement = AgreementFactory(
partner=partner,
country_programme=CountryProgrammeFactory(wbs="random WBS"),
attached_agreement="fake_attachment.pdf",
start=datetime.date.today(),
end=datetime.date.today(),
signed_by_unicef_date=datetime.date.today(),
signed_by=cls.unicef_staff,
signed_by_partner_date=datetime.date.today()
)
agreement.authorized_officers.add(partnerstaff)
agreement.save()
AgreementFactory(signed_by_unicef_date=datetime.date.today())
cls.intervention = InterventionFactory(
agreement=agreement,
document_type=Intervention.SHPD,
status='draft',
start=datetime.date.today(),
end=datetime.date.today(),
submission_date=datetime.date.today(),
submission_date_prc=datetime.date.today(),
review_date_prc=datetime.date.today(),
signed_by_unicef_date=datetime.date.today(),
signed_by_partner_date=datetime.date.today(),
unicef_signatory=cls.unicef_staff,
population_focus="Population focus",
partner_authorized_officer_signatory=partnerstaff,
country_programme=agreement.country_programme,
)
cls.ib = InterventionBudgetFactory(
intervention=cls.intervention,
currency="USD"
)
cls.attachment = InterventionAttachmentFactory(
intervention=cls.intervention,
)
cls.planned_visit = InterventionPlannedVisitsFactory(
intervention=cls.intervention,
)
def test_cp_previous(self):
date_past = datetime.date.today() - datetime.timedelta(days=10)
date_future = datetime.date.today() + datetime.timedelta(days=10)
partner = PartnerFactory()
cp_previous = CountryProgrammeFactory(
from_date=date_past,
to_date=datetime.date.today(),
)
agreement_previous = AgreementFactory(
partner=partner,
agreement_type=Agreement.PCA,
country_programme=cp_previous,
)
cp = CountryProgrammeFactory(
from_date=datetime.date.today() + datetime.timedelta(days=1),
to_date=date_future,
)
AgreementFactory(
partner=partner,
agreement_type=Agreement.PCA,
country_programme=cp,
)
InterventionFactory(
document_type=Intervention.PD,
start=date_past + datetime.timedelta(days=1),
end=datetime.date.today() + datetime.timedelta(days=1),
agreement=agreement_previous,
)
mock_send = Mock()
with patch(self.send_path, mock_send):
utils.send_pca_missing_notifications()
self.assertEqual(mock_send.call_count, 0)
def test_invalid_pca(self):
"""The agreement transition validation fails if;
- Agreement type is PCA
AND there exists an agreement that has ALL of the following;
- same partner
- status is SIGNED
- agreement type is PCA
- same country programme
- start date > 2015-07-01
"""
partner = PartnerFactory()
country = CountryProgrammeFactory()
AgreementFactory(partner=partner,
agreement_type=Agreement.PCA,
status=Agreement.SIGNED,
country_programme=country,
start=datetime.date.today())
agreement = AgreementFactory(
partner=partner,
agreement_type=Agreement.PCA,
country_programme=country,
)
with self.assertRaises(TransitionError):
agreements.agreement_transition_to_signed_valid(agreement)
def test_delete_with_signed_agreements(self):
# create draft agreement with partner
AgreementFactory(partner=self.partner,
signed_by_unicef_date=datetime.date.today())
AgreementFactory(partner=self.partner,
signed_by_unicef_date=None,
signed_by_partner_date=None,
attached_agreement=None,
status='draft')
# should have 1 signed and 1 draft agreement with self.partner
self.assertEqual(self.partner.agreements.count(), 2)
response = self.forced_auth_req(
'delete',
self.url,
user=self.unicef_staff,
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
response.data[0],
"There was a PCA/SSFA signed with this partner or a transaction "
"was performed against this partner. The Partner record cannot be deleted"
)
self.assertTrue(
PartnerOrganization.objects.filter(pk=self.partner.pk).exists())
def setUpTestData(cls):
cls.unicef_staff = UserFactory(is_staff=True)
cls.partner = PartnerFactory(
partner_type=PartnerType.UN_AGENCY,
vendor_number='Vendor No',
short_name="Short Name",
alternate_name="Alternate Name",
shared_with=["DPKO", "ECA"],
address="Address 123",
phone_number="Phone no 1234567",
email="*****@*****.**",
rating=PartnerOrganization.RATING_HIGH,
core_values_assessment_date=datetime.date.today(),
total_ct_cp=10000,
total_ct_cy=20000,
net_ct_cy=100.0,
reported_cy=300.0,
total_ct_ytd=400.0,
deleted_flag=False,
blocked=False,
type_of_assessment="Type of Assessment",
last_assessment_date=datetime.date.today(),
)
cls.partnerstaff = PartnerStaffFactory(partner=cls.partner)
attachment = tempfile.NamedTemporaryFile(suffix=".pdf").name
cls.agreement = AgreementFactory(
partner=cls.partner,
country_programme=CountryProgrammeFactory(wbs="random WBS"),
attached_agreement=attachment,
start=datetime.date.today(),
end=datetime.date.today(),
signed_by_unicef_date=datetime.date.today(),
signed_by=cls.unicef_staff,
signed_by_partner_date=datetime.date.today())
cls.agreement.authorized_officers.add(cls.partnerstaff)
cls.agreement.save()
# This is here to test partner scoping
AgreementFactory(signed_by_unicef_date=datetime.date.today())
cls.intervention = InterventionFactory(
agreement=cls.agreement,
document_type='SHPD',
status='draft',
start=datetime.date.today(),
end=datetime.date.today(),
submission_date=datetime.date.today(),
submission_date_prc=datetime.date.today(),
review_date_prc=datetime.date.today(),
signed_by_unicef_date=datetime.date.today(),
signed_by_partner_date=datetime.date.today(),
unicef_signatory=cls.unicef_staff,
population_focus="Population focus",
partner_authorized_officer_signatory=cls.partnerstaff,
country_programme=cls.agreement.country_programme,
)
cls.ib = InterventionBudgetFactory(intervention=cls.intervention,
currency="USD")
cls.planned_visit = PartnerPlannedVisitsFactory(partner=cls.partner)
output_res_type, _ = ResultType.objects.get_or_create(name='Output')
cls.result = ResultFactory(result_type=output_res_type)
def test_make_agreement_status_automatic_transitions_with_valid_agreements(
self, MockAgreementValid, mock_db_connection, mock_logger):
'''Exercise _make_agreement_status_automatic_transitions() when all agreements are valid.'''
end_date = datetime.date.today() - datetime.timedelta(days=2)
# Agreements sort by oldest last, so I make sure my list here is ordered in the same way as they'll be
# pulled out of the database.
agreements = [
AgreementFactory(status=Agreement.SIGNED,
end=end_date,
created=_make_past_datetime(i),
agreement_type=Agreement.MOU) for i in range(3)
]
# Create a few items that should be ignored. If they're not ignored, this test will fail.
# Ignored because of status.
AgreementFactory(status=Agreement.SUSPENDED,
end=end_date,
agreement_type=Agreement.MOU)
# Ignored because of end date.
AgreementFactory(status=Agreement.SIGNED,
end=datetime.date.today() +
datetime.timedelta(days=2),
agreement_type=Agreement.MOU)
# Ignored because of type.
AgreementFactory(status=Agreement.SIGNED,
end=end_date,
agreement_type=Agreement.SSFA)
# Mock AgreementValid() so that it always returns True.
mock_validator = mock.Mock(spec=['is_valid'])
mock_validator.is_valid = True
MockAgreementValid.return_value = mock_validator
# I'm done mocking, it's time to call the function.
etools.applications.partners.tasks._make_agreement_status_automatic_transitions(
self.country_name)
expected_call_args = [((agreement, ), {
'user': self.admin_user,
'disable_rigid_check': True
}) for agreement in agreements]
self._assertCalls(MockAgreementValid, expected_call_args)
# Verify logged messages.
expected_call_args = [
(('Starting agreement auto status transition for country {}'.
format(self.country_name), ), {}),
(('Total agreements 3', ), {}),
(('Transitioned agreements 0 ', ), {}),
]
self._assertCalls(mock_logger.info, expected_call_args)
expected_call_args = [
(('Bad agreements 0', ), {}),
(('Bad agreements ids: ', ), {}),
]
self._assertCalls(mock_logger.error, expected_call_args)
def test_true(self):
agreement = AgreementFactory()
agreement.old_instance = None
self.assertTrue(
agreements.agreements_illegal_transition_permissions(
agreement,
None
)
)
def setUpTestData(cls):
cls.unicef_staff = UserFactory(is_staff=True)
partner = PartnerFactory(
partner_type='Government',
vendor_number='Vendor No',
short_name="Short Name",
alternate_name="Alternate Name",
shared_with=["DPKO", "ECA"],
address="Address 123",
phone_number="Phone no 1234567",
email="*****@*****.**",
rating="High",
core_values_assessment_date=datetime.date.today(),
total_ct_cp=10000,
total_ct_cy=20000,
deleted_flag=False,
blocked=False,
type_of_assessment="Type of Assessment",
last_assessment_date=datetime.date.today(),
)
partnerstaff = PartnerStaffFactory(partner=partner)
agreement = AgreementFactory(
partner=partner,
country_programme=CountryProgrammeFactory(wbs="random WBS"),
attached_agreement="fake_attachment.pdf",
start=datetime.date.today(),
end=datetime.date.today(),
signed_by_unicef_date=datetime.date.today(),
signed_by=cls.unicef_staff,
signed_by_partner_date=datetime.date.today())
agreement.authorized_officers.add(partnerstaff)
agreement.save()
AgreementFactory(signed_by_unicef_date=datetime.date.today())
cls.intervention = InterventionFactory(
agreement=agreement,
document_type=Intervention.SHPD,
status='draft',
start=datetime.date.today(),
end=datetime.date.today(),
submission_date=datetime.date.today(),
submission_date_prc=datetime.date.today(),
review_date_prc=datetime.date.today(),
signed_by_unicef_date=datetime.date.today(),
signed_by_partner_date=datetime.date.today(),
unicef_signatory=cls.unicef_staff,
population_focus="Population focus",
partner_authorized_officer_signatory=partnerstaff,
country_programme=agreement.country_programme,
)
cls.ib = InterventionBudgetFactory(intervention=cls.intervention,
currency="USD")
cls.attachment = InterventionAttachmentFactory(
intervention=cls.intervention, )
cls.planned_visit = InterventionPlannedVisitsFactory(
intervention=cls.intervention, )
def test_notification(self):
agreement = AgreementFactory(partner=PartnerFactory(name='xyz'))
notification = NotificationFactory(sender=agreement)
self.assertIn('Email Notification from', str(notification))
self.assertIn('for xyz', str(notification))
agreement = AgreementFactory(partner=PartnerFactory(name='R\xe4dda Barnen'))
notification = NotificationFactory(sender=agreement)
self.assertIn('Email Notification from', str(notification))
self.assertIn('for R\xe4dda Barnen', str(notification))
def test_create_fail_one_PCA_per_country_programme_and_partner(self):
"""Ensure correct error is raised for PCAs with duplicate country programme & partner combo"""
AgreementFactory(
agreement_type=Agreement.PCA,
partner=self.partner,
country_programme=self.country_programme,
)
# Create an agreement of exactly the same type.
data = {
"agreement_type": Agreement.PCA,
"partner": self.partner,
"country_programme": self.country_programme,
}
serializer = AgreementCreateUpdateSerializer()
serializer.context['request'] = self.fake_request
with self.assertRaises(serializers.ValidationError) as context_manager:
serializer.validate(data=data)
self.assertSimpleExceptionFundamentals(
context_manager,
'A PCA with this partner already exists for this Country Programme Cycle. '
'If the record is in "Draft" status please edit that record.'
)
def test_invalid(self):
agreement = AgreementFactory(
agreement_type=Agreement.MOU,
start=datetime.date.today(),
end=datetime.date.today() - datetime.timedelta(days=1),
)
self.assertFalse(agreements.start_end_dates_valid(agreement))
def test_patch_agreement_replace_attachment(self):
agreement = AgreementFactory(partner=self.partner1,
status=Agreement.DRAFT)
attachment_current = AttachmentFactory(
content_object=agreement,
file_type=self.file_type_agreement,
code=self.file_type_agreement.code,
file="old_file.pdf",
)
attachment_new = AttachmentFactory(
file="new_file.pdf",
file_type=None,
code="",
)
status_code, response = self.run_request(agreement.pk)
self.assertEqual(status_code, status.HTTP_200_OK)
self.assertTrue(response["attachment"].endswith(
attachment_current.file.url))
data = {"attachment": attachment_new.pk}
status_code, response = self.run_request(
agreement.pk,
data,
method="patch",
)
self.assertEqual(status_code, status.HTTP_200_OK)
self.assertTrue(response["attachment"].endswith(
attachment_new.file.url))
agreement_updated = Agreement.objects.get(pk=agreement.pk)
self.assertEqual(agreement_updated.attachment.last(), attachment_new)
def setUpTestData(cls):
cls.unicef_staff = UserFactory(is_staff=True)
partner = PartnerFactory(
partner_type='Government',
vendor_number='Vendor No',
short_name="Short Name",
alternate_name="Alternate Name",
shared_with=["DPKO", "ECA"],
address="Address 123",
phone_number="Phone no 1234567",
email="*****@*****.**",
rating="High",
core_values_assessment_date=datetime.date.today(),
total_ct_cp=10000,
total_ct_cy=20000,
deleted_flag=False,
blocked=False,
type_of_assessment="Type of Assessment",
last_assessment_date=datetime.date.today(),
)
partnerstaff = PartnerStaffFactory(partner=partner)
cls.agreement = AgreementFactory(
partner=partner,
country_programme=CountryProgrammeFactory(wbs="random WBS"),
attached_agreement="fake_attachment.pdf",
start=datetime.date.today(),
end=datetime.date.today(),
signed_by_unicef_date=datetime.date.today(),
signed_by=cls.unicef_staff,
signed_by_partner_date=datetime.date.today()
)
cls.agreement.authorized_officers.add(partnerstaff)
cls.agreement.save()
def test_create_ok_non_PCA_with_same_programme_and_partner(self):
"""Ensure it is OK to create non-PCA agreements that have the same country programme and partner.
This is a sibling test to test_create_fail_one_PCA_per_country_programme_and_partner().
"""
agreement_types = [
agreement_type for agreement_type in _ALL_AGREEMENT_TYPES
if agreement_type != Agreement.PCA
]
for agreement_type in agreement_types:
AgreementFactory(
agreement_type=agreement_type,
partner=self.partner,
country_programme=self.country_programme,
)
# Create an agreement of exactly the same type.
data = {
"agreement_type": agreement_type,
"partner": self.partner.id,
"country_programme": self.country_programme.id,
"reference_number_year": datetime.date.today().year
}
serializer = AgreementCreateUpdateSerializer(data=data)
serializer.context['request'] = self.fake_request
self.assertTrue(serializer.is_valid(raise_exception=True))
def setUpTestData(cls):
cls.file_type_partner = AttachmentFileTypeFactory(
code="partners_partner_assessment")
cls.file_type_agreement = AttachmentFileTypeFactory(
code="partners_agreement")
cls.file_type_assessment = AttachmentFileTypeFactory(
code="partners_assessment_report")
cls.file_type_agreement_amendment = AttachmentFileTypeFactory(
code="partners_agreement_amendment")
cls.file_type_intervention_prc_review = AttachmentFileTypeFactory(
code="partners_intervention_prc_review")
cls.file_type_intervention_signed_pd = AttachmentFileTypeFactory(
code="partners_intervention_signed_pd")
cls.file_type_intervention_amendment = AttachmentFileTypeFactory(
code="partners_intervention_amendment_signed")
cls.file_type_intervention_attachment = AttachmentFileTypeFactory(
code="partners_intervention_attachment")
cls.partner = PartnerFactory()
cls.core_values_assessment = CoreValuesAssessmentFactory(
assessment="sample.pdf")
cls.agreement = AgreementFactory(attached_agreement="sample.pdf")
cls.assessment = AssessmentFactory(report="sample.pdf")
cls.agreement_amendment = AgreementAmendmentFactory(
signed_amendment="sample.pdf")
cls.intervention = InterventionFactory(
prc_review_document="prc_sample.pdf",
signed_pd_document="pd_sample.pdf")
cls.intervention_amendment = InterventionAmendmentFactory(
signed_amendment="sample.pdf")
cls.intervention_attachment = InterventionAttachmentFactory(
attachment="sample.pdf")
def get_fixtures(self):
agreement = AgreementFactory(signed_by_unicef_date=datetime.date.today())
agreement_amendment = AgreementAmendmentFactory(agreement=agreement)
return {
'agreement': agreement,
'agreement_amendment': agreement_amendment,
}
def test_invalid(self):
agreement = AgreementFactory(
agreement_type=Agreement.MOU,
signed_by_unicef_date=datetime.date.today(),
signed_by_partner_date=None,
)
self.assertFalse(agreements.signed_by_everyone_valid(agreement))
def setUp(self):
super().setUp()
self.agreement = AgreementFactory(agreement_type=Agreement.SSFA, )
self.intervention = InterventionFactory(
document_type=Intervention.SSFA,
agreement=self.agreement,
)
def test_patch_agreement_with_attachment_as_pk(self):
agreement = AgreementFactory(partner=self.partner1,
status=Agreement.DRAFT)
attachment = AttachmentFactory(
file="test_file.pdf",
file_type=None,
code="",
)
self.assertIsNone(attachment.content_object)
self.assertIsNone(attachment.file_type)
self.assertEqual(attachment.code, "")
data = {"attachment": attachment.pk}
status_code, response = self.run_request(
agreement.pk,
data,
method="patch",
)
self.assertEqual(status_code, status.HTTP_200_OK)
self.assertTrue(response["attachment"].endswith(attachment.file.url))
attachment_update = Attachment.objects.get(pk=attachment.pk)
self.assertEqual(attachment_update.content_object, agreement)
self.assertEqual(attachment_update.file_type, self.file_type_agreement)
self.assertEqual(attachment_update.code, self.file_type_agreement.code)
def test_update_fail_due_to_amendments_unsigned(self):
"""Ensure agreement update fails if amendments aren't signed.
I don't think it's possible to supply amendments when creating via the serializer, so this only tests update.
"""
agreement = AgreementFactory(agreement_type=Agreement.MOU,
signed_by_unicef_date=None,
signed_by_partner_date=None)
amendment = AgreementAmendmentFactory(agreement=agreement)
data = {
'agreement': agreement,
'amendments': [amendment],
}
serializer = AgreementCreateUpdateSerializer()
# If I don't set serializer.instance, the validator gets confused. I guess (?) this is ordinarily set by DRF
# during an update?
serializer.instance = agreement
serializer.context['request'] = self.fake_request
with self.assertRaises(serializers.ValidationError) as context_manager:
serializer.validate(data=data)
self.assertAmendmentExceptionFundamentals(
context_manager,
'Please check that the Document is attached and signatures are not in the future'
)
def setUp(self):
super(TestSSFAgreementHasNoOtherIntervention, self).setUp()
self.agreement = AgreementFactory(agreement_type=Agreement.SSFA, )
self.intervention = InterventionFactory(
document_type=Intervention.SSFA,
agreement=self.agreement,
)
def test_exception(self):
agreement = AgreementFactory(
agreement_type=Agreement.SSFA,
signed_by_unicef_date=datetime.date.today(),
)
with self.assertRaises(BasicValidationError):
agreements.signatures_valid(agreement)
def setUpTestData(cls):
cls.code_1 = "test_code_1"
cls.file_type_1 = AttachmentFileTypeFactory(code=cls.code_1)
cls.code_2 = "test_code_2"
cls.file_type_2 = AttachmentFileTypeFactory(code=cls.code_2)
cls.unicef_staff = UserFactory(is_staff=True)
cls.user = UserFactory()
cls.url = reverse("attachments:list")
cls.attachment_1 = AttachmentFactory(
file_type=cls.file_type_1,
code=cls.code_1,
file="sample1.pdf",
content_object=cls.file_type_1,
uploaded_by=cls.unicef_staff
)
cls.attachment_2 = AttachmentFactory(
file_type=cls.file_type_2,
code=cls.code_2,
file="sample2.pdf",
content_object=cls.file_type_2,
uploaded_by=cls.user
)
cls.partner = PartnerFactory(
partner_type=PartnerType.UN_AGENCY,
vendor_number="V123",
)
cls.agreement = AgreementFactory(partner=cls.partner)
cls.assessment = AssessmentFactory(partner=cls.partner)
cls.amendment = AgreementAmendmentFactory(agreement=cls.agreement)
cls.intervention = InterventionFactory(agreement=cls.agreement)
cls.result_link = InterventionResultLinkFactory(
intervention=cls.intervention
)
cls.intervention_amendment = InterventionAmendmentFactory(
intervention=cls.intervention
)
cls.intervention_attachment = InterventionAttachmentFactory(
intervention=cls.intervention
)
cls.tpm_partner = SimpleTPMPartnerFactory(vendor_number="V432")
cls.tpm_visit = TPMVisitFactory(tpm_partner=cls.tpm_partner)
cls.tpm_activity = TPMActivityFactory(
partner=cls.partner,
intervention=cls.intervention,
tpm_visit=cls.tpm_visit
)
cls.engagement = EngagementFactory(partner=cls.partner)
cls.default_partner_response = [{
"partner": "",
"partner_type": "",
"vendor_number": "",
"pd_ssfa_number": "",
"agreement_reference_number": "",
"source": "",
}] * 2
def test_valid(self):
agreement = AgreementFactory(
agreement_type=Agreement.MOU,
start=datetime.date.today(),
end=datetime.date.today(),
)
self.assertTrue(
agreements.agreement_transition_to_signed_valid(agreement))
def test_valid(self):
agreement = AgreementFactory()
AgreementAmendmentFactory(
agreement=agreement,
signed_amendment='fake.pdf',
signed_date=datetime.date.today(),
)
self.assertTrue(agreements.amendments_valid(agreement))
def test_save_model_update(self):
self.assertFalse(Activity.objects.exists())
obj = AgreementFactory(partner=self.partner)
status_before = obj.status
obj.status = Agreement.TERMINATED
aa = AgreementAdmin(Agreement, self.site)
aa.save_model(self.request, obj, {}, True)
self.assertTrue(
Activity.objects.filter(action=Activity.UPDATE).exists())
activity = Activity.objects.first()
self.assertEqual(activity.target, obj)
self.assertEqual(activity.by_user, self.user)
self.assertEqual(activity.change, {
"status": {
"before": status_before,
"after": Agreement.TERMINATED
}
})
def test_get(self):
partner = PartnerFactory()
agreement = AgreementFactory(partner=partner)
intervention_1 = InterventionFactory(agreement=agreement)
intervention_2 = InterventionFactory(agreement=agreement)
intervention_3 = InterventionFactory()
res = tags.get_interventions(partner.pk)
self.assertIn(intervention_1.number, res)
self.assertIn(intervention_2.number, res)
self.assertNotIn(intervention_3.number, res)
def test_save_model_update(self):
self.assertFalse(Activity.objects.exists())
obj = AgreementFactory(partner=self.partner)
status_before = obj.status
obj.status = Agreement.TERMINATED
aa = AgreementAdmin(Agreement, self.site)
aa.save_model(self.request, obj, {}, True)
self.assertTrue(
Activity.objects.filter(action=Activity.UPDATE).exists()
)
activity = Activity.objects.first()
self.assertEqual(activity.target, obj)
self.assertEqual(activity.by_user, self.user)
self.assertEqual(activity.change, {
"status": {
"before": status_before,
"after": Agreement.TERMINATED
}
})
def test_fail_transition_to_ended(self):
"""Exercise transition to ended."""
# First test valid/positive case
agreement = AgreementFactory(agreement_type=Agreement.MOU,
status=Agreement.SIGNED,
end=self.today - datetime.timedelta(days=3),
signed_by_unicef_date=None,
signed_by_partner_date=None)
data = {
"agreement": agreement,
"status": Agreement.ENDED,
}
serializer = AgreementCreateUpdateSerializer()
# If I don't set serializer.instance, the validator gets confused. I guess (?) this is ordinarily set by DRF?
# # during an update?
serializer.instance = agreement
serializer.context['request'] = self.fake_request
# This should succeed
serializer.validate(data=data)
# Should fail; no end date set.
agreement = AgreementFactory(agreement_type=Agreement.MOU,
status=Agreement.SIGNED,
signed_by_unicef_date=None,
signed_by_partner_date=None)
data = {
"agreement": agreement,
"status": Agreement.ENDED,
}
serializer = AgreementCreateUpdateSerializer()
# If I don't set serializer.instance, the validator gets confused. I guess (?) this is ordinarily set by DRF?
# # during an update?
serializer.instance = agreement
serializer.context['request'] = self.fake_request
with self.assertRaises(serializers.ValidationError) as context_manager:
serializer.validate(data=data)
self.assertSimpleExceptionFundamentals(
context_manager,
'agreement_transition_to_ended_invalid'
)
def test_no_issue(self):
"""Check that is attached agreement, then no issue"""
qs_issue = FlaggedIssue.objects.filter(
issue_id="active_pca_no_signed_doc")
agreement = AgreementFactory()
self.assertTrue(agreement.attachment.exists())
self.assertEqual(agreement.agreement_type, Agreement.PCA)
self.assertFalse(qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertFalse(qs_issue.exists())
def test_agreement_cp(self):
cp = CountryProgrammeFactory(to_date=self.lead_date)
agreement = AgreementFactory(country_programme=cp)
InterventionFactory(
document_type=Intervention.PD,
end=self.lead_date + datetime.timedelta(days=10),
agreement=agreement,
)
mock_send = Mock()
with patch(self.send_path, mock_send):
utils.send_pca_required_notifications()
self.assertEqual(mock_send.call_count, 1)
def test_valid(self):
partner = PartnerFactory()
user = UserFactory()
staff = PartnerStaffFactory(partner=partner, )
agreement = AgreementFactory(
partner=partner,
signed_by_unicef_date=datetime.date.today(),
signed_by=user,
signed_by_partner_date=datetime.date.today(),
partner_manager=staff,
)
self.assertTrue(agreements.signatures_valid(agreement))
def test_valid(self):
agreement = AgreementFactory(
agreement_type=Agreement.MOU,
status=Agreement.SIGNED,
start=datetime.date(2001, 1, 1),
end=datetime.date(2001, 1, 2),
)
self.assertEqual(agreement.status, Agreement.SIGNED)
self.assertTrue(agreement.end)
self.assertTrue(agreement.end < datetime.date.today())
self.assertTrue(
agreements.agreement_transition_to_ended_valid(agreement))
def test_fail_transition_to_signed_start_and_end_dates(self):
"""Exercise transition to signed, and validation related to start and end dates."""
agreement = AgreementFactory(agreement_type=Agreement.MOU,
status=Agreement.DRAFT,
signed_by_unicef_date=None,
signed_by_partner_date=None)
data = {
"agreement": agreement,
"status": Agreement.SIGNED,
}
serializer = AgreementCreateUpdateSerializer()
# If I don't set serializer.instance, the validator gets confused. I guess (?) this is ordinarily set by DRF
# during an update?
serializer.instance = agreement
serializer.context['request'] = self.fake_request
# Should fail because start date is empty.
with self.assertRaises(serializers.ValidationError) as context_manager:
serializer.validate(data=data)
self.assertSimpleExceptionFundamentals(
context_manager,
'Agreement cannot transition to signed until the start date is less than or equal to today'
)
# Populate start date, but with a date that's still invalid (in the future)
agreement.start = self.today + datetime.timedelta(days=5)
agreement.save()
# Should fail because start date is in the future
with self.assertRaises(serializers.ValidationError) as context_manager:
serializer.validate(data=data)
self.assertSimpleExceptionFundamentals(
context_manager,
'Agreement cannot transition to signed until the start date is less than or equal to today'
)
# Fix problem with start date, now allow blank end date to cause a failure.
agreement.start = self.today - datetime.timedelta(days=5)
agreement.save()
with self.assertRaises(serializers.ValidationError) as context_manager:
serializer.validate(data=data)
self.assertSimpleExceptionFundamentals(
context_manager,
'Agreement cannot transition to signed unless the end date is defined'
)
# Populate end date with a date in the past - should pass validation for MOU's
agreement.end = self.today - datetime.timedelta(days=3)
self.assertTrue(serializer.validate(data=data))
# Fix end date
agreement.end = self.today
agreement.save()
# Should not raise an exception
serializer.validate(data=data)
