def test_valid_hyperlink(self):
valid_hyperlink_attachment = AttachmentFactory(
hyperlink='http://example.com/test_file.txt', content_object=self.simple_object
)
valid_hyperlink_attachment.clean()
self.assertIsNotNone(valid_hyperlink_attachment.hyperlink)
self.assertEqual(valid_hyperlink_attachment.url, valid_hyperlink_attachment.hyperlink)
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.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_add_new_PCA_with_amendment(self):
attachment = AttachmentFactory(
file="test_file.pdf",
file_type=None,
code="",
)
attachment_amendment = AttachmentFactory(
file="test_file_amendment.pdf",
file_type=None,
code="",
)
self.assertIsNone(attachment.file_type)
self.assertIsNone(attachment.content_object)
self.assertFalse(attachment.code)
self.assertIsNone(attachment_amendment.file_type)
self.assertIsNone(attachment_amendment.content_object)
self.assertFalse(attachment_amendment.code)
self.assertFalse(Activity.objects.exists())
data = {
"agreement_type":
Agreement.PCA,
"reference_number_year":
datetime.date.today().year,
"partner":
self.partner1.id,
"country_programme":
self.country_programme.id,
"attachment":
attachment.pk,
"amendments": [{
"types": [
AgreementAmendment.CLAUSE,
],
"signed_date":
datetime.date.today().strftime("%Y-%m-%d"),
"signed_amendment_attachment":
attachment_amendment.pk,
}]
}
status_code, response = self.run_request_list_ep(data)
self.assertEqual(status_code, status.HTTP_201_CREATED)
self.assertEqual(response['agreement_type'], Agreement.PCA)
self.assertEqual(
Activity.objects.filter(action=Activity.CREATE).count(), 1)
attachment_updated = Attachment.objects.get(pk=attachment.pk)
self.assertEqual(attachment_updated.file_type.code,
self.file_type_agreement.code)
self.assertEqual(attachment_updated.object_id, response["id"])
self.assertEqual(attachment_updated.code,
self.file_type_agreement.code)
attachment_amendment_updated = Attachment.objects.get(
pk=attachment_amendment.pk)
self.assertEqual(attachment_amendment_updated.file_type.code,
self.file_type_agreement_amendment.code)
self.assertEqual(attachment_amendment_updated.object_id,
response["amendments"][0]["id"])
self.assertEqual(attachment_amendment_updated.code,
self.file_type_agreement_amendment.code)
def test_valid_file(self):
valid_file_attachment = AttachmentFactory(
# Note: file content is intended to be a byte-string here.
file=SimpleUploadedFile('simple_file.txt', b'these are the file contents!'),
content_object=self.simple_object
)
valid_file_attachment.clean()
self.assertIsNotNone(valid_file_attachment.file)
self.assertEqual(valid_file_attachment.url, valid_file_attachment.file.url)
def test_str(self):
instance = AttachmentFactory(file=SimpleUploadedFile(
'simple_file.txt', b'these are the file contents!'),
content_object=self.simple_object)
self.assertIn('simple_file', str(instance))
instance = AttachmentFactory(file=SimpleUploadedFile(
'simple_file.txt', u'R\xe4dda Barnen'.encode('utf-8')),
content_object=self.simple_object)
self.assertIn('simple_file', str(instance))
def setUp(self):
self.assessment = AssessmentFactory(
partner=self.partner,
completed_date=None,
report=None,
)
self.attachment = AttachmentFactory(
file="test_file.pdf",
file_type=None,
code="",
)
def test_last_attachment(self):
self.file_type.attachment = Attachment.objects.filter(code=self.code)
field = fields.AttachmentSingleFileField(source="attachment")
AttachmentFactory(
file_type=self.file_type,
content_object=self.file_type,
code=self.code,
)
attachment = AttachmentFactory(
file_type=self.file_type,
content_object=self.file_type,
code=self.code,
file=self.file_data,
)
self.assertEqual(field.get_attribute(self.file_type), attachment.file)
def test_intervention_amendment(self):
code = "partners_intervention_amendment_signed"
file_type = AttachmentFileTypeFactory(code=code)
AttachmentFactory(file_type=file_type,
code=code,
file="sample1.pdf",
content_object=self.intervention_amendment,
uploaded_by=self.user)
response = self.forced_auth_req(
"get",
self.url,
user=self.unicef_staff,
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 3)
self.assert_keys(response)
self.assert_values(
response, self.default_partner_response + [{
"partner":
self.partner.name,
"partner_type":
self.partner.partner_type,
"vendor_number":
self.partner.vendor_number,
"pd_ssfa_number":
self.intervention.number,
"agreement_reference_number":
self.intervention.agreement.reference_number,
}])
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_patch_with_assessment_attachment(self):
attachment = AttachmentFactory(
file="test_file.pdf",
file_type=None,
code="",
)
self.assertIsNone(attachment.file_type)
self.assertIsNone(attachment.content_object)
self.assertFalse(attachment.code)
assessment_qs = Assessment.objects.filter(partner=self.partner)
self.assertFalse(assessment_qs.exists())
response = self.forced_auth_req('patch',
self.url,
data={
"assessments": [{
"report_attachment":
attachment.pk,
"completed_date":
datetime.date.today(),
"type":
Assessment.TYPE_OTHER,
}]
},
user=self.unicef_staff)
data = json.loads(response.rendered_content)
self.assertEqual(response.status_code, 200)
self.assertEqual(data["id"], self.partner.pk)
self.assertEqual(data["interventions"][0]["id"], self.intervention.pk)
self.assertTrue(assessment_qs.exists())
self.assertEqual(len(data["assessments"]), 1)
self.assertEqual(data["assessments"][0]["report_attachment"],
attachment.file.url)
def test_auditor_with_attachment(self):
file_type = AttachmentFileTypeFactory(code="audit_report")
AttachmentFactory(file="test_report.pdf",
file_type=file_type,
code=file_type.code,
content_object=self.engagement)
self._test_pdf_view(self.auditor)
def test_patch_with_core_values_assessment_attachment(self):
attachment = AttachmentFactory(
file="test_file.pdf",
file_type=None,
code="",
)
self.assertIsNone(attachment.file_type)
self.assertIsNone(attachment.content_object)
self.assertFalse(attachment.code)
assessment_qs = CoreValuesAssessment.objects.filter(
partner=self.partner)
self.assertFalse(assessment_qs.exists())
response = self.forced_auth_req(
'patch',
self.url,
data={"core_values_assessments": [{
"attachment": attachment.pk
}]},
user=self.unicef_staff)
data = json.loads(response.rendered_content)
self.assertEqual(response.status_code, 200)
self.assertEqual(data["id"], self.partner.pk)
self.assertEqual(data["interventions"][0]["id"], self.intervention.pk)
self.assertTrue(assessment_qs.exists())
self.assertEqual(len(data["core_values_assessments"]), 1)
self.assertEqual(data["core_values_assessments"][0]["attachment"],
attachment.file.url)
def setUp(self):
self.attachment = AttachmentFactory(file_type=self.file_type,
code=self.file_type.code,
content_object=self.file_type)
self.file_data = SimpleUploadedFile('hello_world.txt',
u'hello world!'.encode('utf-8'))
self.url = reverse("attachments:update", args=[self.attachment.pk])
def test_audit_engagement_report_attachments(self):
code = "audit_report"
file_type = AttachmentFileTypeFactory(label="Audit Report", code=code)
AttachmentFactory(file_type=file_type,
code=code,
file="sample3.pdf",
content_object=self.engagement,
uploaded_by=self.user)
response = self.forced_auth_req(
"get",
self.url,
user=self.unicef_staff,
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 3)
self.assert_keys(response)
self.assert_values(
response,
self.default_partner_response + [{
"partner": self.partner.name,
"partner_type": self.partner.partner_type,
"vendor_number": self.partner.vendor_number,
"pd_ssfa_number": "",
"agreement_reference_number": "",
}])
self.assertCountEqual(
[x["file_type"] for x in response.data],
[self.file_type_1.label, self.file_type_2.label, file_type.label])
def test_tpm_activity_attachments(self):
code = "activity_attachments"
file_type = AttachmentFileTypeFactory(
label="Activity Attachment",
code=code
)
AttachmentFactory(
file_type=file_type,
code=code,
file="sample3.pdf",
content_object=self.tpm_activity,
uploaded_by=self.user
)
response = self.forced_auth_req(
"get",
self.url,
user=self.unicef_staff,
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 3)
self.assert_keys(response)
self.assert_values(response, self.default_partner_response + [{
"partner": self.partner.name,
"partner_type": self.partner.partner_type,
"vendor_number": self.partner.vendor_number,
"pd_ssfa_number": self.intervention.number,
"agreement_reference_number": self.intervention.agreement.reference_number,
"source": "Third Party Monitoring",
}])
self.assertCountEqual([x["file_type"] for x in response.data], [
self.file_type_1.label,
self.file_type_2.label,
file_type.label
])
def test_add_attachment(self):
travel = TravelFactory()
attachment = AttachmentFactory(
file="test_file.pdf",
file_type=None,
code="",
)
self.assertIsNone(attachment.file_type)
self.assertIsNone(attachment.content_object)
self.assertFalse(attachment.code)
attachment_qs = TravelAttachment.objects.filter(
travel=travel
)
self.assertFalse(attachment_qs.exists())
data = {
'name': 'second',
'type': 'something',
'attachment': attachment.pk,
}
response = self.forced_auth_req(
'post',
reverse(
't2f:travels:details:attachments',
kwargs={'travel_pk': travel.pk}
),
data=data,
user=self.unicef_staff,
request_format='multipart',
)
response_json = json.loads(response.rendered_content)
expected_keys = ['file', 'id', 'name', 'type', 'url', 'attachment']
self.assertKeysIn(expected_keys, response_json)
self.assertTrue(attachment_qs.exists())
def test_intervention_attachment(self):
code = "partners_intervention_attachment"
file_type = AttachmentFileTypeFactory(code=code)
AttachmentFactory(
file_type=file_type,
code=code,
file="sample1.pdf",
content_object=self.intervention_attachment,
uploaded_by=self.user
)
response = self.forced_auth_req(
"get",
self.url,
user=self.unicef_staff,
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 3)
self.assert_keys(response)
self.assert_values(response, self.default_partner_response + [{
"partner": self.partner.name,
"partner_type": self.partner.partner_type,
"vendor_number": self.partner.vendor_number,
"pd_ssfa_number": self.intervention.number,
"agreement_reference_number": self.intervention.agreement.reference_number,
"source": "Partnership Management Portal",
}])
self.assertCountEqual([x["file_type"] for x in response.data], [
self.file_type_1.label,
self.file_type_2.label,
self.intervention_attachment.type.name
])
def test_str(self):
attachment = AttachmentFactory(file=SimpleUploadedFile(
'simple_file.txt', u'R\xe4dda Barnen'.encode('utf-8')),
content_object=self.simple_object)
flat_qs = AttachmentFlat.objects.filter(attachment=attachment)
self.assertTrue(flat_qs.exists())
flat = flat_qs.first()
self.assertEqual(str(flat), str(attachment.file))
def test_activity_attachment_without_intervention(self):
visit = TPMVisitFactory(tpm_activities__count=1)
activity = visit.tpm_activities.first()
activity.intervention = None
activity.save()
attachment = AttachmentFactory(content_object=activity)
denormalize_attachment(attachment)
def report_attachments(self, create, extracted, count, **kwargs):
if not create:
return
for i in range(count):
AttachmentFactory(code='visit_report',
content_object=self,
**kwargs)
def test_intervention_update(self):
attachment_prc = AttachmentFactory(
content_object=self.intervention,
file_type=self.file_type_intervention_prc_review,
code=self.file_type_intervention_prc_review.code,
file="random.pdf")
attachment_pd = AttachmentFactory(
content_object=self.intervention,
file_type=self.file_type_intervention_signed_pd,
code=self.file_type_intervention_signed_pd.code,
file="random.pdf")
call_command("copy_attachments")
attachment_prc_update = Attachment.objects.get(pk=attachment_prc.pk)
self.assertEqual(attachment_prc_update.file.name,
self.intervention.prc_review_document.name)
attachment_pd_update = Attachment.objects.get(pk=attachment_pd.pk)
self.assertEqual(attachment_pd_update.file.name,
self.intervention.signed_pd_document.name)
def test_agreement_detail_attachment(self):
attachment = AttachmentFactory(content_object=self.agreement1,
file_type=self.file_type_agreement,
code=self.file_type_agreement.code,
file="test_file.pdf")
status_code, response = self.run_request(self.agreement1.pk)
self.assertEqual(status_code, status.HTTP_200_OK)
self.assertTrue(response["attachment"].endswith(attachment.file.url))
def test_agreement_update(self):
attachment = AttachmentFactory(content_object=self.agreement,
file_type=self.file_type_agreement,
code=self.file_type_agreement.code,
file="random.pdf")
call_command("copy_attachments")
attachment_update = Attachment.objects.get(pk=attachment.pk)
self.assertEqual(attachment_update.file.name,
self.agreement.attached_agreement.name)
def setUpTestData(cls):
cls.code = "test_code_1"
cls.file_type = AttachmentFileTypeFactory(code=cls.code)
cls.unicef_staff = UserFactory(is_staff=True)
cls.attachment = AttachmentFactory(file_type=cls.file_type,
code=cls.code,
file="sample1.pdf",
content_object=cls.file_type,
uploaded_by=cls.unicef_staff)
cls.url = reverse("attachments:file", args=[cls.attachment.pk])
def test_start_date_after_signed_date_attachment(self):
"""Start date after max signed date is valid"""
intervention = InterventionFactory(
signed_by_unicef_date=datetime.date(2001, 2, 1),
signed_by_partner_date=datetime.date(2001, 3, 1),
start=datetime.date(2001, 4, 1))
AttachmentFactory(file="random.pdf",
code="partners_intervention_signed_pd",
content_object=intervention)
self.assertTrue(start_date_signed_valid(intervention))
def test_call(self):
attachment = AttachmentFactory(
content_object=self.core_value_assessment,
file_type=self.file_type_partner,
code=self.file_type_partner.code,
file="random.pdf")
etools.applications.partners.tasks.copy_attachments()
attachment_update = Attachment.objects.get(pk=attachment.pk)
self.assertEqual(attachment_update.file.name,
self.core_value_assessment.assessment.name)
def test_partner_update(self):
attachment = AttachmentFactory(
content_object=self.core_values_assessment,
file_type=self.file_type_partner,
code=self.file_type_partner.code,
file="random.pdf")
call_command("copy_attachments")
attachment_update = Attachment.objects.get(pk=attachment.pk)
self.assertEqual(attachment_update.file.name,
self.core_values_assessment.assessment)
def test_intervention(self):
code_prc = "partners_intervention_prc_review"
file_type_prc = AttachmentFileTypeFactory(code=code_prc)
code_pd = "partners_intervention_signed_pd"
file_type_pd = AttachmentFileTypeFactory(code=code_pd)
AttachmentFactory(
file_type=file_type_prc,
code=code_prc,
file="sample1.pdf",
content_object=self.intervention,
uploaded_by=self.user
)
AttachmentFactory(
file_type=file_type_pd,
code=code_pd,
file="sample1.pdf",
content_object=self.intervention,
uploaded_by=self.user
)
response = self.forced_auth_req(
"get",
self.url,
user=self.unicef_staff,
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 4)
self.assert_keys(response)
self.assert_values(response, self.default_partner_response + [{
"partner": self.partner.name,
"partner_type": self.partner.partner_type,
"vendor_number": self.partner.vendor_number,
"pd_ssfa_number": self.intervention.number,
"agreement_reference_number": self.intervention.agreement.reference_number,
"source": "Partnership Management Portal",
}, {
"partner": self.partner.name,
"partner_type": self.partner.partner_type,
"vendor_number": self.partner.vendor_number,
"pd_ssfa_number": self.intervention.number,
"agreement_reference_number": self.intervention.agreement.reference_number,
"source": "Partnership Management Portal",
}])
def setUp(self):
self.assessment = AssessmentFactory(
partner=self.partner,
completed_date=None,
report=None,
)
self.attachment = AttachmentFactory(
file="test_file.pdf",
file_type=None,
code="",
)
def test_list_tpm_user(self):
attachments_num = self.tpm_partner.attachments.count()
AttachmentFactory(content_object=self.tpm_partner)
response = self.forced_auth_req('get',
reverse('tpm:partner-attachments-list',
args=[self.tpm_partner.pk]),
user=self.tpm_user)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data['results']), attachments_num + 1)
class TestPartnerOrganizationAssessmentUpdateDeleteView(BaseTenantTestCase):
@classmethod
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.partner_staff = PartnerStaffFactory(partner=cls.partner)
cls.partnership_manager_user = UserFactory(is_staff=True)
cls.partnership_manager_user.groups.add(GroupFactory())
cls.partnership_manager_user.profile.partner_staff_member = cls.partner_staff.id
cls.partnership_manager_user.save()
def setUp(self):
self.assessment = AssessmentFactory(
partner=self.partner,
completed_date=None,
report=None,
)
self.attachment = AttachmentFactory(
file="test_file.pdf",
file_type=None,
code="",
)
def test_post(self):
assessment_qs = Assessment.objects.filter(partner=self.partner)
assessment_count = assessment_qs.count()
response = self.forced_auth_req(
'post',
reverse('partners_api:partner-assessment'),
user=self.partnership_manager_user,
data={
"partner": self.partner.pk,
"type": Assessment.TYPE_OTHER,
"report_attachment": self.attachment.pk,
"completed_date": datetime.date.today(),
}
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(assessment_qs.count(), assessment_count + 1)
self.attachment.refresh_from_db()
self.assertTrue(self.attachment.file_type)
def test_patch(self):
self.assertTrue(self.assessment.active)
response = self.forced_auth_req(
'patch',
reverse(
'partners_api:partner-assessment-detail',
args=[self.assessment.pk]
),
user=self.partnership_manager_user,
data={
"active": False
}
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assessment.refresh_from_db()
self.assertFalse(self.assessment.active)
def test_patch_permission(self):
response = self.forced_auth_req(
'patch',
reverse(
'partners_api:partner-assessment-detail',
args=[self.assessment.pk]
),
user=self.unicef_staff,
data={
"active": False
}
)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_valid(self):
response = self.forced_auth_req(
'delete',
reverse(
'partners_api:partner-assessment-detail',
args=[self.assessment.pk]
),
user=self.partnership_manager_user,
)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_delete_error_completed_date(self):
assessment = AssessmentFactory(
partner=self.partner,
report=None,
)
response = self.forced_auth_req(
'delete',
reverse(
'partners_api:partner-assessment-detail',
args=[assessment.pk]
),
user=self.partnership_manager_user,
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data, ["Cannot delete a completed assessment"])
def test_delete_error_report(self):
assessment = AssessmentFactory(
partner=self.partner,
completed_date=None,
)
response = self.forced_auth_req(
'delete',
reverse(
'partners_api:partner-assessment-detail',
args=[assessment.pk]
),
user=self.partnership_manager_user,
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data, ["Cannot delete a completed assessment"])
def test_delete_permission(self):
response = self.forced_auth_req(
'delete',
reverse(
'partners_api:partner-assessment-detail',
args=[self.assessment.pk]
),
user=self.unicef_staff,
)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_not_found(self):
response = self.forced_auth_req(
'delete',
reverse(
'partners_api:partner-assessment-detail',
args=[404]
),
user=self.partnership_manager_user,
)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
