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)
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='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.planned_visit = InterventionPlannedVisitsFactory(
intervention=cls.intervention,
)
cls.attachment = InterventionAttachmentFactory(
intervention=cls.intervention,
)
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_true(self):
agreement = AgreementFactory()
agreement.old_instance = None
self.assertTrue(
agreements.agreements_illegal_transition_permissions(
agreement,
None
)
)
def test_notification(self):
agreement = AgreementFactory(partner=PartnerFactory(name=b'xyz'))
notification = NotificationFactory(sender=agreement)
self.assertIn(u'Email Notification from', six.text_type(notification))
self.assertIn(u'for xyz', six.text_type(notification))
agreement = AgreementFactory(partner=PartnerFactory(
name=u'R\xe4dda Barnen'))
notification = NotificationFactory(sender=agreement)
self.assertIn(u'Email Notification from', six.text_type(notification))
self.assertIn(u'for R\xe4dda Barnen', six.text_type(notification))
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.
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_invalid_no_start(self):
"""Agreement transition validation fails if no start date"""
agreement = AgreementFactory(
agreement_type=Agreement.MOU,
)
with self.assertRaises(TransitionError):
agreements.agreement_transition_to_signed_valid(agreement)
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_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_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 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 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_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 test_invalid_date(self):
agreement = AgreementFactory()
AgreementAmendmentFactory(
agreement=agreement,
signed_amendment='fake.pdf'
)
self.assertFalse(agreements.amendments_valid(agreement))
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(core_values_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 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_assert(self):
"""If no old_instance attribute set on agreement, raise an exception"""
agreement = AgreementFactory()
with self.assertRaises(AssertionError):
agreements.agreements_illegal_transition_permissions(
agreement,
None
)
def test_invalid_no_end(self):
"""Agreement transition validation fails if no end date"""
agreement = AgreementFactory(
agreement_type=Agreement.MOU,
start=datetime.date.today()
)
with self.assertRaises(TransitionError):
agreements.agreement_transition_to_signed_valid(agreement)
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_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_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_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_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_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.attached_agreement)
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_no_issue_ssfa(self):
"""Check that if agreement type PCA and document type SSFA
then issue is NOT raised
"""
agreement = AgreementFactory(agreement_type=Agreement.PCA)
InterventionFactory(
agreement=agreement,
document_type=Intervention.PD,
)
self.assertFalse(self.qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertFalse(self.qs_issue.exists())
def test_save_model_create(self):
self.assertFalse(Activity.objects.exists())
agreement = AgreementFactory()
ia = InterventionAdmin(Intervention, self.site)
obj = Intervention(agreement=agreement)
ia.save_model(self.request, obj, {}, False)
self.assertTrue(
Activity.objects.filter(action=Activity.CREATE).exists()
)
activity = Activity.objects.first()
self.assertEqual(activity.target, obj)
self.assertEqual(activity.by_user, self.user)
self.assertEqual(activity.change, {})
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_start_date_after_signed_date(self):
"""Start date after agreement start date is invalid
If not contingency_pd, and certain document_type
"""
agreement = AgreementFactory()
intervention = InterventionFactory(
agreement=agreement,
signed_pd_document="random.pdf",
start=datetime.date.today() + datetime.timedelta(days=2),
contingency_pd=False,
document_type=Intervention.PD,
)
self.assertTrue(start_date_related_agreement_valid(intervention))
def test_update_with_due_to_amendments_signed_date(self):
"""Ensure agreement update fails if amendments don't have a signed_date or if it's in the future,
and that update succeeds when the amendments signatures meet criteria.
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)
# I need to give amendment.signed_amendment a name to exercise the date part of the amendment validator.
amendment.signed_amendment.name = 'fake_amendment.pdf'
amendment.save()
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'
)
# Set the signed date, but set it to the future which should cause a failure.
amendment.signed_date = self.today + datetime.timedelta(days=5)
amendment.save()
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'
)
# Change the amendment so it will pass validation.
amendment.signed_date = self.today
amendment.save()
# Should not raise an error.
serializer.validate(data=data)
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))
