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_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 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 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_create_with_partner_type(self): """Exercise create success & failure related to the rules regarding agreement type and partner type""" # Set partner to something other than civil society org. self.partner.partner_type = PartnerType.UN_AGENCY self.partner.save() # Create PCA & SSFA should fail now. for agreement_type in (Agreement.PCA, Agreement.SSFA): data = { "agreement_type": agreement_type, "country_programme": self.country_programme, "partner": self.partner, "reference_number_year": datetime.date.today().year } serializer = AgreementCreateUpdateSerializer(data=data) serializer.context['request'] = self.fake_request with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, 'Partner type must be CSO for PCA or SSFA agreement types.' ) # Test for all agreement types that are not PCA or SSFA. These should not fail. agreement_types = [agreement_type for agreement_type in _ALL_AGREEMENT_TYPES if agreement_type not in (Agreement.PCA, Agreement.SSFA)] for agreement_type in agreement_types: data = { "agreement_type": agreement_type, "country_programme": self.country_programme.id, "partner": self.partner.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)) # Set partner to civil service org; create all agreement types should succeed self.partner.partner_type = PartnerType.CIVIL_SOCIETY_ORGANIZATION self.partner.save() for agreement_type in _ALL_AGREEMENT_TYPES: data = { "agreement_type": agreement_type, "country_programme": self.country_programme.id, "partner": self.partner.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 test_simple_create(self): data = { "agreement_type": Agreement.MOU, "partner": self.partner.id, } serializer = AgreementCreateUpdateSerializer(data=data) serializer.context['request'] = self.fake_request self.assertTrue(serializer.is_valid(raise_exception=True))
def test_simple_create(self): data = { "agreement_type": Agreement.MOU, "partner": self.partner.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 test_create_ok_with_start_date_equal_end_date(self): """Ensure it's OK to create an agreement where the start & end dates are the same.""" data = { "agreement_type": Agreement.PCA, "partner": self.partner.id, "country_programme": self.country_programme.id, "start": self.today, "end": self.today, } serializer = AgreementCreateUpdateSerializer(data=data) serializer.context['request'] = self.fake_request self.assertTrue(serializer.is_valid(raise_exception=True))
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_create_ok_with_start_date_equal_end_date(self): """Ensure it's OK to create an agreement where the start & end dates are the same.""" data = { "agreement_type": Agreement.PCA, "partner": self.partner.id, "country_programme": self.country_programme.id, "start": self.today, "end": self.today, "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 test_create_fail_country_programme_required_for_PCA(self): """Ensure correct error is raised for PCAs with no country programme""" data = { "agreement_type": Agreement.PCA, "partner": self.partner.id, } serializer = AgreementCreateUpdateSerializer() serializer.context['request'] = self.fake_request with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) exception = context_manager.exception self.assertIsInstance(exception.detail, dict) self.assertEqual(list(exception.detail.keys()), ['country_programme']) self.assertEqual(exception.detail['country_programme'], 'Country Programme is required for PCAs!')
def test_create_fail_due_to_signatures_SSFA(self): """Ensure signature validation works correctly for SSFA""" data = { "agreement_type": Agreement.SSFA, "partner": self.partner, "signed_by_unicef_date": self.today, } serializer = AgreementCreateUpdateSerializer() serializer.context['request'] = self.fake_request with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, 'SSFA signatures are captured at the Document (TOR) level, please clear the ' 'signatures and dates and add them to the TOR')
def test_create_fail_due_to_signatures_SSFA(self): """Ensure signature validation works correctly for SSFA""" data = { "agreement_type": Agreement.SSFA, "partner": self.partner, "signed_by_unicef_date": self.today, } serializer = AgreementCreateUpdateSerializer() serializer.context['request'] = self.fake_request with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, 'SSFA signatures are captured at the Document (TOR) level, please clear the ' 'signatures and dates and add them to the TOR' )
def test_ensure_field_read_write_status(self): """Ensure that the fields I expect to be read-only are read-only; also confirm the converse""" expected_read_only_fields = ('id', 'created', 'modified', 'partner_name', 'amendments', 'unicef_signatory', 'partner_signatory', 'agreement_number', 'attached_agreement_file', 'signed_by') serializer = AgreementCreateUpdateSerializer() for field_name, field in serializer.fields.items(): expected_read_only = (field_name in expected_read_only_fields) self.assertEqual(field.read_only, expected_read_only)
def test_create_fail_start_date_after_end_date(self): """Ensure create fails if start date is after end date""" data = { "agreement_type": Agreement.PCA, "partner": self.partner, "country_programme": self.country_programme, "start": self.today + datetime.timedelta(days=5), "end": self.today, } serializer = AgreementCreateUpdateSerializer() serializer.context['request'] = self.fake_request with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, 'Agreement start date needs to be earlier than or the same as the end date' )
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_update_fail_due_to_uneditable_field(self): """Exercise changing a field that can't be changed while the agreement has this status.""" agreement = AgreementFactory(agreement_type=Agreement.MOU, status=Agreement.DRAFT, signed_by_unicef_date=None, signed_by_partner_date=None) data = { "agreement": agreement, "partner": self.partner, } 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, "Cannot change fields while in draft: partner" )
def test_create_ok_when_start_or_end_not_present(self): """Ensure that date validation doesn't kick in when one date or another isn't present""" # Test w/start date present but not end date data = { "agreement_type": Agreement.SSFA, "partner": self.partner.id, "start": self.today + datetime.timedelta(days=5), } serializer = AgreementCreateUpdateSerializer(data=data) serializer.context['request'] = self.fake_request self.assertTrue(serializer.is_valid(raise_exception=True)) # Test w/end date present but not start date data = { "agreement_type": Agreement.SSFA, "partner": self.partner.id, "end": self.today + datetime.timedelta(days=5), } serializer = AgreementCreateUpdateSerializer(data=data) serializer.context['request'] = self.fake_request self.assertTrue(serializer.is_valid(raise_exception=True))
def test_update_fail_due_to_uneditable_field(self): """Exercise changing a field that can't be changed while the agreement has this status.""" agreement = AgreementFactory(agreement_type=Agreement.MOU, status=Agreement.DRAFT, signed_by_unicef_date=None, signed_by_partner_date=None) data = { "agreement": agreement, "partner": self.partner, } 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, "Cannot change fields while in draft: partner")
def test_create_ok_when_start_or_end_not_present(self): """Ensure that date validation doesn't kick in when one date or another isn't present""" # Test w/start date present but not end date data = { "agreement_type": Agreement.SSFA, "partner": self.partner.id, "start": self.today + datetime.timedelta(days=5), "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)) # Test w/end date present but not start date data = { "agreement_type": Agreement.SSFA, "partner": self.partner.id, "end": self.today + datetime.timedelta(days=5), "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 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)
def test_update_intervention(self): """Ensure agreement update fails if intervention dates aren't appropriate. I don't think it's possible to supply interventions when creating via the serializer, so this only tests update. """ agreement = AgreementFactory( agreement_type=Agreement.SSFA, partner=self.partner, status=Agreement.DRAFT, start=self.today - datetime.timedelta(days=5), end=self.today + datetime.timedelta(days=5), signed_by_unicef_date=None, signed_by_partner_date=None, reference_number_year=datetime.date.today().year) intervention = InterventionFactory(agreement=agreement) # Start w/an invalid intervention. data = { "agreement": agreement, "intervention": intervention, } 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, "Start and end dates don't match the Document's start and end") # Set start date and save again; it should still fail because end date isn't set. intervention.start = agreement.start intervention.save() with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, "Start and end dates don't match the Document's start and end") # Set start date and save again; it should still fail because end date doesn't match agreement end date. intervention.end = agreement.end + datetime.timedelta(days=100) intervention.save() with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, "Start and end dates don't match the Document's start and end") # Set start date and save again; it should now succeed. intervention.end = agreement.end intervention.save() # Should not raise an exception serializer.validate(data=data)
def test_create_ok_and_fail_due_to_signatures_non_SSFA(self): """Ensure signature validation works correctly for non-SSFA types""" signatory = UserFactory() partner_signatory = PartnerStaffFactory(partner=self.partner) # This should succeed; it's OK to have only one set of signatures (UNICEF) data = { "agreement_type": Agreement.MOU, "partner": self.partner.id, "signed_by_unicef_date": self.today, "signed_by": signatory.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)) # This should succeed; it's OK to have only one set of signatures (partner) data = { "agreement_type": Agreement.MOU, "partner": self.partner.id, "signed_by_partner_date": self.today, "signed_by": signatory.id, "partner_manager": partner_signatory.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)) # This should succeed; it's OK to have both sets of signatures (UNICEF & partner) data = { "agreement_type": Agreement.MOU, "partner": self.partner.id, "signed_by_unicef_date": self.today, "signed_by": signatory.id, "signed_by_partner_date": self.today, "partner_manager": partner_signatory.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)) # This should fail because signed_by_unicef_date and signed_by are both set, but the signed by date is # in the future. data = { "agreement_type": Agreement.MOU, "partner": self.partner, "signed_by_unicef_date": self.today + datetime.timedelta(days=5), "signed_by": signatory, "reference_number_year": datetime.date.today().year } with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, 'None of the signatures can be dated in the future') # This should fail because signed_by_partner_date and partner_manager are both set, but the signed by date is # in the future. data = { "agreement_type": Agreement.MOU, "partner": self.partner, "signed_by_partner_date": self.today + datetime.timedelta(days=5), "partner_manager": partner_signatory, "reference_number_year": datetime.date.today().year } with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, 'None of the signatures can be dated in the future')
def test_create_with_partner_type(self): """Exercise create success & failure related to the rules regarding agreement type and partner type""" # Set partner to something other than civil society org. self.partner.partner_type = PartnerType.UN_AGENCY self.partner.save() # Create PCA & SSFA should fail now. for agreement_type in (Agreement.PCA, Agreement.SSFA): data = { "agreement_type": agreement_type, "country_programme": self.country_programme, "partner": self.partner, "reference_number_year": datetime.date.today().year } serializer = AgreementCreateUpdateSerializer(data=data) serializer.context['request'] = self.fake_request with self.assertRaises( serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, 'Partner type must be CSO for PCA or SSFA agreement types.') # Test for all agreement types that are not PCA or SSFA. These should not fail. agreement_types = [ agreement_type for agreement_type in _ALL_AGREEMENT_TYPES if agreement_type not in (Agreement.PCA, Agreement.SSFA) ] for agreement_type in agreement_types: data = { "agreement_type": agreement_type, "country_programme": self.country_programme.id, "partner": self.partner.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)) # Set partner to civil service org; create all agreement types should succeed self.partner.partner_type = PartnerType.CIVIL_SOCIETY_ORGANIZATION self.partner.save() for agreement_type in _ALL_AGREEMENT_TYPES: data = { "agreement_type": agreement_type, "country_programme": self.country_programme.id, "partner": self.partner.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 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_update_intervention(self): """Ensure agreement update fails if intervention dates aren't appropriate. I don't think it's possible to supply interventions when creating via the serializer, so this only tests update. """ agreement = AgreementFactory(agreement_type=Agreement.SSFA, partner=self.partner, status=Agreement.DRAFT, start=self.today - datetime.timedelta(days=5), end=self.today + datetime.timedelta(days=5), signed_by_unicef_date=None, signed_by_partner_date=None, reference_number_year=datetime.date.today().year) intervention = InterventionFactory(agreement=agreement) # Start w/an invalid intervention. data = { "agreement": agreement, "intervention": intervention, } 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, "Start and end dates don't match the Document's start and end" ) # Set start date and save again; it should still fail because end date isn't set. intervention.start = agreement.start intervention.save() with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, "Start and end dates don't match the Document's start and end" ) # Set start date and save again; it should still fail because end date doesn't match agreement end date. intervention.end = agreement.end + datetime.timedelta(days=100) intervention.save() with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, "Start and end dates don't match the Document's start and end" ) # Set start date and save again; it should now succeed. intervention.end = agreement.end intervention.save() # Should not raise an exception serializer.validate(data=data)
def test_create_ok_and_fail_due_to_signatures_non_SSFA(self): """Ensure signature validation works correctly for non-SSFA types""" signatory = UserFactory() partner_signatory = PartnerStaffFactory(partner=self.partner) # This should succeed; it's OK to have only one set of signatures (UNICEF) data = { "agreement_type": Agreement.MOU, "partner": self.partner.id, "signed_by_unicef_date": self.today, "signed_by": signatory.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)) # This should succeed; it's OK to have only one set of signatures (partner) data = { "agreement_type": Agreement.MOU, "partner": self.partner.id, "signed_by_partner_date": self.today, "signed_by": signatory.id, "partner_manager": partner_signatory.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)) # This should succeed; it's OK to have both sets of signatures (UNICEF & partner) data = { "agreement_type": Agreement.MOU, "partner": self.partner.id, "signed_by_unicef_date": self.today, "signed_by": signatory.id, "signed_by_partner_date": self.today, "partner_manager": partner_signatory.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)) # This should fail because signed_by_unicef_date and signed_by are both set, but the signed by date is # in the future. data = { "agreement_type": Agreement.MOU, "partner": self.partner, "signed_by_unicef_date": self.today + datetime.timedelta(days=5), "signed_by": signatory, "reference_number_year": datetime.date.today().year } with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, 'None of the signatures can be dated in the future' ) # This should fail because signed_by_partner_date and partner_manager are both set, but the signed by date is # in the future. data = { "agreement_type": Agreement.MOU, "partner": self.partner, "signed_by_partner_date": self.today + datetime.timedelta(days=5), "partner_manager": partner_signatory, "reference_number_year": datetime.date.today().year } with self.assertRaises(serializers.ValidationError) as context_manager: serializer.validate(data=data) self.assertSimpleExceptionFundamentals( context_manager, 'None of the signatures can be dated in the future' )