def test_cso_types(self):
'''Verify the cso_types portion of the response'''
PartnerFactory(cso_type=PartnerOrganization.CSO_TYPES['International'])
# These should be filtered out of the endpoint response (https://github.com/unicef/etools/issues/510)
PartnerFactory(cso_type=None)
PartnerFactory(cso_type='')
response = self.forced_auth_req('get', self.url)
d = self._assertResponseFundamentals(response)
self.assertEqual(d['cso_types'], [{'value': PartnerOrganization.CSO_TYPES['International'],
'label': PartnerOrganization.CSO_TYPES['International']}])
def test_run_all_checks(self):
PartnerFactory(
short_name='A name'
) # make a good one as well just to ensure it's not flagging everything
partner_bad = PartnerFactory()
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertEqual(1, FlaggedIssue.objects.count())
issue = FlaggedIssue.objects.first()
self.assertEqual(PartnersMustHaveShortNameTestCheck.check_id,
issue.issue_id)
self.assertEqual(partner_bad, issue.content_object)
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_recheck(self):
partner_bad = PartnerFactory()
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertEqual(1, FlaggedIssue.objects.count())
issue = FlaggedIssue.objects.first()
self.assertEqual(PartnersMustHaveShortNameTestCheck.check_id,
issue.issue_id)
self.assertEqual(partner_bad, issue.content_object)
self.assertEqual(ISSUE_STATUS_NEW, issue.issue_status)
update_date = issue.date_updated
# initial recheck should not do anything except modify timestamps
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_NEW, issue.issue_status)
self.assertNotEqual(update_date, issue.date_updated)
update_date = issue.date_updated
# recheck after fixing the issue should update the status to resolved
partner_bad.short_name = 'Name added'
partner_bad.save()
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_RESOLVED, issue.issue_status)
self.assertNotEqual(update_date, issue.date_updated)
update_date = issue.date_updated
# recheck after re-creating the issue should update the status to reactivated
partner_bad.short_name = ''
partner_bad.save()
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_REACTIVATED, issue.issue_status)
self.assertNotEqual(update_date, issue.date_updated)
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 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 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_recheck_all_open_issues(self):
"""Check that recheck_all_open_issues call changes those issues
that are not resolved
And handles invalid issues
"""
partner = PartnerFactory(short_name='A name')
issue_resolved = FlaggedIssueFactory(
content_object=partner,
issue_id='partners_must_have_short_name',
issue_status=ISSUE_STATUS_RESOLVED,
)
issue_new = FlaggedIssueFactory(
content_object=partner,
issue_id='partners_must_have_short_name',
issue_status=ISSUE_STATUS_NEW,
)
issue_bad = FlaggedIssueFactory(
content_object=partner,
issue_status=ISSUE_STATUS_NEW,
)
checks.recheck_all_open_issues()
issue_resolved_updated = FlaggedIssue.objects.get(pk=issue_resolved.pk)
self.assertEqual(issue_resolved_updated.date_updated,
issue_resolved.date_updated)
issue_new_updated = FlaggedIssue.objects.get(pk=issue_new.pk)
self.assertNotEqual(issue_new_updated.date_updated,
issue_new.date_updated)
issue_bad_updated = FlaggedIssue.objects.get(pk=issue_bad.pk)
self.assertEqual(issue_bad_updated.date_updated,
issue_bad.date_updated)
def test_recheck_with_metadata(self):
partner_bad = PartnerFactory(name='bar')
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertEqual(1, FlaggedIssue.objects.count())
issue = FlaggedIssue.objects.first()
self.assertEqual(PartnersNameMustBeFooTestCheck.check_id,
issue.issue_id)
self.assertEqual(partner_bad, issue.content_object)
self.assertEqual(ISSUE_STATUS_NEW, issue.issue_status)
partner_bad.name = 'foo'
partner_bad.save()
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_RESOLVED, issue.issue_status)
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 setUpTestData(cls):
cls.url = reverse("partners_api:partner-hact")
cls.unicef_staff = UserFactory(is_staff=True)
cls.partner = PartnerFactory(
total_ct_cp=10.00,
total_ct_cy=8.00,
)
def test_partner_staff(self):
partner = PartnerFactory()
partner_staff = PartnerStaffFactory(partner=partner)
fields = utils.get_to_many_field_names(partner_staff.__class__)
# check many_to_one field
self.assertIn("signed_interventions", fields)
# check many_to_many field
self.assertIn("agreement_authorizations", fields)
def test_clean_email_no_change(self):
"""Ensure valid if no change in email """
partner = PartnerFactory()
staff = PartnerStaffFactory(
partner=partner,
email="*****@*****.**",
)
form = forms.PartnerStaffMemberForm(self.data, instance=staff)
self.assertTrue(form.is_valid())
def test_get_or_new_returns_saved(self):
issue_id = 'test-return-saved'
partner = PartnerFactory()
issue = FlaggedIssueFactory(content_object=partner,
issue_id=issue_id,
message='test message')
self.assertTrue(issue.pk is not None)
issue_back = FlaggedIssue.get_or_new(partner, issue_id)
# make sure we got the same one back
self.assertEqual(issue.pk, issue_back.pk)
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_records_update_name(self):
"""Check that partner organization record is updated,
name changed
"""
partner = PartnerFactory(name="New",
vendor_number=self.data["VENDOR_CODE"])
response = self.adapter._save_records([self.data])
self.assertEqual(response, 1)
partner_updated = PartnerOrganization.objects.get(pk=partner.pk)
self.assertEqual(partner_updated.name, self.data["VENDOR_NAME"])
def test_delete(self):
partner = PartnerFactory()
response = self.forced_auth_req(
'delete',
reverse('partners_api:partner-delete', args=[partner.pk]),
user=self.unicef_staff,
)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(
PartnerOrganization.objects.filter(pk=partner.pk).exists()
)
def test_flagged_issue(self):
partner = PartnerFactory()
issue = FlaggedIssueFactory(content_object=partner,
issue_id="321",
message='test message')
self.assertEqual(six.text_type(issue), u"test message")
issue = FlaggedIssueFactory(content_object=partner,
issue_id="321",
message=u"R\xe4dda Barnen")
self.assertEqual(six.text_type(issue), u"R\xe4dda Barnen")
def test_save_records_update_deleted_flag(self):
"""Check that partner organization record is updated,
deleted_flag changed
"""
self.data["MARKED_FOR_DELETION"] = True
partner = PartnerFactory(name=self.data["VENDOR_NAME"],
vendor_number=self.data["VENDOR_CODE"],
deleted_flag=False)
response = self.adapter._save_records([self.data])
self.assertEqual(response, 1)
partner_updated = PartnerOrganization.objects.get(pk=partner.pk)
self.assertTrue(partner_updated.deleted_flag)
def setUpTestData(cls):
cls.unicef_staff = UserFactory(is_staff=True)
cls.partner = PartnerFactory(
partner_type=PartnerType.CIVIL_SOCIETY_ORGANIZATION,
cso_type="International",
hidden=False,
vendor_number="DDD",
short_name="Short name",
)
cls.url = reverse(
'partners_api:partner-delete',
args=[cls.partner.pk]
)
def test_clean_activate(self):
"""If staff member made active, ensure user not already associated
with another partner
"""
UserFactory(email="*****@*****.**")
partner = PartnerFactory()
staff = PartnerStaffFactory(
partner=partner,
email="*****@*****.**",
active=False
)
form = forms.PartnerStaffMemberForm(self.data, instance=staff)
self.assertTrue(form.is_valid())
def test_save_records_update(self):
"""Check that partner organization record is NOT updated,
if no change
"""
PartnerFactory(
name=self.data["VENDOR_NAME"],
vendor_number=self.data["VENDOR_CODE"],
country=self.data["COUNTRY"],
partner_type="UN Agency",
total_ct_cp=self.data["TOTAL_CASH_TRANSFERRED_CP"],
total_ct_cy=self.data["TOTAL_CASH_TRANSFERRED_CY"],
)
response = self.adapter._save_records([self.data])
self.assertEqual(response, 1)
def setUpTestData(cls):
cls.unicef_user = UserFactory(is_staff=True)
cls.partner = PartnerFactory(
name="Partner Name",
partner_type=PartnerType.UN_AGENCY,
shared_with=[PartnerOrganization.AGENCY_CHOICES.UN],
rating=PartnerOrganization.RATING_HIGH,
total_ct_cp=200.0,
total_ct_cy=150.0,
net_ct_cy=100.0,
reported_cy=300.0,
total_ct_ytd=400.0,
)
cls.url = reverse("hact_api:hact-history")
def setUpTestData(cls):
cls.user = UserFactory()
cls.partner = PartnerFactory(partner_type=PartnerType.CIVIL_SOCIETY_ORGANIZATION)
cls.today = datetime.date.today()
# The serializer examines context['request'].user during the course of its operation. If that's not set, the
# serializer will fail. It doesn't need a real request object, just something with a .user attribute, so
# that's what I create here.
class Stub(object):
pass
cls.fake_request = Stub()
cls.fake_request.user = cls.user
def test_clean_email_change(self):
"""Email address may not be changed"""
self.data["email"] = "*****@*****.**"
partner = PartnerFactory()
staff = PartnerStaffFactory(
partner=partner,
email="*****@*****.**",
)
form = forms.PartnerStaffMemberForm(self.data, instance=staff)
self.assertFalse(form.is_valid())
self.assertIn(
"User emails cannot be changed, please remove the user and add another one: [email protected]",
form.errors["__all__"]
)
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 setUpTestData(cls):
cls.aggregate_hact = AggregateHactFactory()
cls.partner = PartnerFactory(
name="Partner Name",
partner_type=PartnerType.CIVIL_SOCIETY_ORGANIZATION,
shared_with=[PartnerOrganization.AGENCY_CHOICES.UN],
rating=PartnerOrganization.RATING_HIGH,
total_ct_cp=200.0,
total_ct_cy=400.0,
net_ct_cy=110000.0,
reported_cy=300.0,
total_ct_ytd=140000.0,
)
cls.partner2 = PartnerFactory(
name="Partner Name",
partner_type=PartnerType.GOVERNMENT,
shared_with=[PartnerOrganization.AGENCY_CHOICES.UNHCR],
rating=PartnerOrganization.RATING_LOW,
total_ct_cp=200.0,
total_ct_cy=2200.0,
net_ct_cy=510000.0,
reported_cy=52000.0,
total_ct_ytd=550000.0,
)
AuditFactory(
status=Engagement.FINAL,
audit_opinion=Audit.OPTION_UNQUALIFIED,
date_of_draft_report_to_unicef=datetime(datetime.today().year, 1,
3),
additional_supporting_documentation_provided=1000.0,
justification_provided_and_accepted=20000.0,
write_off_required=30000.0,
amount_refunded=400000.0,
audited_expenditure=50.0,
financial_findings=999.0,
)
def test_invalid(self):
tomorrow = datetime.date.today() + datetime.timedelta(days=1)
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=tomorrow,
partner_manager=staff,
)
self.assertFalse(agreements.signatures_valid(agreement))
def test_delete_with_cash_trxs(self):
partner = PartnerFactory(total_ct_cp=20.00)
response = self.forced_auth_req(
'delete',
reverse('partners_api:partner-delete', args=[partner.pk]),
user=self.unicef_staff,
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
response.data[0],
"This partner has cash transactions associated to it"
)
self.assertTrue(
PartnerOrganization.objects.filter(pk=partner.pk).exists()
)
def test_save_records_update_date(self):
"""Check that partner organization record is updated,
last assessment date changed
"""
self.data["DATE_OF_ASSESSMENT"] = "4-Apr-17"
partner = PartnerFactory(
name=self.data["VENDOR_NAME"],
vendor_number=self.data["VENDOR_CODE"],
country=self.data["COUNTRY"],
last_assessment_date=datetime.date(2017, 4, 5),
)
response = self.adapter._save_records([self.data])
self.assertEqual(response, 1)
partner_updated = PartnerOrganization.objects.get(pk=partner.pk)
self.assertEqual(partner_updated.last_assessment_date,
datetime.date(2017, 4, 4))
