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)