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))