def test_no_interventions(self):
"""If intervention does not fit in with Country Programmes
then no issues raised
"""
qs_issue = FlaggedIssue.objects.filter(
issue_id="pd_outputs_wrong"
)
start_date = datetime.date(2001, 1, 1)
end_date = datetime.date(2001, 12, 31)
country = CountryProgrammeFactory(
from_date=start_date,
to_date=end_date,
)
intervention = InterventionFactory(
country_programme=country,
start=start_date - datetime.timedelta(days=1),
)
result = ResultFactory(country_programme=CountryProgrammeFactory())
InterventionResultLink.objects.create(
intervention=intervention,
cp_output=result,
)
self.assertNotEqual(
intervention.country_programme,
result.country_programme
)
self.assertFalse(qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertFalse(qs_issue.exists())
def test_no_interventions(self):
"""If intervention does not fit in with Country Programmes
then no issues raised
"""
qs_issue = FlaggedIssue.objects.filter(issue_id="pd_outputs_wrong")
start_date = datetime.date(2001, 1, 1)
end_date = datetime.date(2001, 12, 31)
country = CountryProgrammeFactory(
from_date=start_date,
to_date=end_date,
)
intervention = InterventionFactory(
country_programme=country,
start=start_date - datetime.timedelta(days=1),
)
result = ResultFactory(country_programme=CountryProgrammeFactory())
InterventionResultLink.objects.create(
intervention=intervention,
cp_output=result,
)
self.assertNotEqual(intervention.country_programme,
result.country_programme)
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(self):
"""Check that valida interventions results in no issue"""
qs_issue = FlaggedIssue.objects.filter(
issue_id="pd_outputs_wrong"
)
start_date = datetime.date(2001, 1, 1)
end_date = datetime.date(2001, 12, 31)
country = CountryProgrammeFactory(
from_date=start_date,
to_date=end_date,
)
intervention = InterventionFactory(
country_programme=country,
start=start_date,
)
result = ResultFactory(country_programme=country)
InterventionResultLink.objects.create(
intervention=intervention,
cp_output=result,
)
self.assertEqual(
intervention.country_programme,
result.country_programme
)
self.assertFalse(qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertFalse(qs_issue.exists())
def test_recheck(self):
partner_bad = PartnerFactory()
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertEqual(1, FlaggedIssue.objects.count())
issue = FlaggedIssue.objects.first()
self.assertEqual(PartnersMustHaveShortNameTestCheck.check_id, issue.issue_id)
self.assertEqual(partner_bad, issue.content_object)
self.assertEqual(ISSUE_STATUS_NEW, issue.issue_status)
update_date = issue.date_updated
# initial recheck should not do anything except modify timestamps
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_NEW, issue.issue_status)
self.assertNotEqual(update_date, issue.date_updated)
update_date = issue.date_updated
# recheck after fixing the issue should update the status to resolved
partner_bad.short_name = 'Name added'
partner_bad.save()
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_RESOLVED, issue.issue_status)
self.assertNotEqual(update_date, issue.date_updated)
update_date = issue.date_updated
# recheck after re-creating the issue should update the status to reactivated
partner_bad.short_name = ''
partner_bad.save()
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_REACTIVATED, issue.issue_status)
self.assertNotEqual(update_date, issue.date_updated)
def test_issue_found(self):
"""Check that is country programme for intervention does not
match result country programme then issue is created"""
qs_issue = FlaggedIssue.objects.filter(issue_id="pd_outputs_wrong")
start_date = datetime.date(2001, 1, 1)
end_date = datetime.date(2001, 12, 31)
country = CountryProgrammeFactory(
from_date=start_date,
to_date=end_date,
)
intervention = InterventionFactory(
country_programme=country,
start=start_date,
)
result = ResultFactory(country_programme=CountryProgrammeFactory())
InterventionResultLink.objects.create(
intervention=intervention,
cp_output=result,
)
self.assertNotEqual(intervention.country_programme,
result.country_programme)
self.assertFalse(qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertTrue(qs_issue.exists())
issue = qs_issue.first()
self.assertIn("has wrongly mapped outputs", issue.message)
def test_recheck(self):
partner_bad = PartnerFactory()
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertEqual(1, FlaggedIssue.objects.count())
issue = FlaggedIssue.objects.first()
self.assertEqual(PartnersMustHaveShortNameTestCheck.check_id,
issue.issue_id)
self.assertEqual(partner_bad, issue.content_object)
self.assertEqual(ISSUE_STATUS_NEW, issue.issue_status)
update_date = issue.date_updated
# initial recheck should not do anything except modify timestamps
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_NEW, issue.issue_status)
self.assertNotEqual(update_date, issue.date_updated)
update_date = issue.date_updated
# recheck after fixing the issue should update the status to resolved
partner_bad.short_name = 'Name added'
partner_bad.save()
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_RESOLVED, issue.issue_status)
self.assertNotEqual(update_date, issue.date_updated)
update_date = issue.date_updated
# recheck after re-creating the issue should update the status to reactivated
partner_bad.short_name = ''
partner_bad.save()
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_REACTIVATED, issue.issue_status)
self.assertNotEqual(update_date, issue.date_updated)
def test_issue_found(self):
"""Check that is country programme for intervention does not
match result country programme then issue is created"""
qs_issue = FlaggedIssue.objects.filter(
issue_id="pd_outputs_wrong"
)
start_date = datetime.date(2001, 1, 1)
end_date = datetime.date(2001, 12, 31)
country = CountryProgrammeFactory(
from_date=start_date,
to_date=end_date,
)
intervention = InterventionFactory(
country_programme=country,
start=start_date,
)
result = ResultFactory(country_programme=CountryProgrammeFactory())
InterventionResultLink.objects.create(
intervention=intervention,
cp_output=result,
)
self.assertNotEqual(
intervention.country_programme,
result.country_programme
)
self.assertFalse(qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertTrue(qs_issue.exists())
issue = qs_issue.first()
self.assertIn("has wrongly mapped outputs", issue.message)
def test_no_issue(self):
"""Check that valida interventions results in no issue"""
qs_issue = FlaggedIssue.objects.filter(issue_id="pd_outputs_wrong")
start_date = datetime.date(2001, 1, 1)
end_date = datetime.date(2001, 12, 31)
country = CountryProgrammeFactory(
from_date=start_date,
to_date=end_date,
)
intervention = InterventionFactory(
country_programme=country,
start=start_date,
)
result = ResultFactory(country_programme=country)
InterventionResultLink.objects.create(
intervention=intervention,
cp_output=result,
)
self.assertEqual(intervention.country_programme,
result.country_programme)
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(self):
"""Check that if amendment file, then issue is NOT raised"""
amendment = InterventionAmendmentFactory()
self.assertTrue(amendment.signed_amendment)
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_no_issue(self):
"""Check that if amendment file, then issue is NOT raised"""
amendment = InterventionAmendmentFactory()
self.assertTrue(amendment.signed_amendment)
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_run_all_checks(self):
PartnerFactory(short_name='A name') # make a good one as well just to ensure it's not flagging everything
partner_bad = PartnerFactory()
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertEqual(1, FlaggedIssue.objects.count())
issue = FlaggedIssue.objects.first()
self.assertEqual(PartnersMustHaveShortNameTestCheck.check_id, issue.issue_id)
self.assertEqual(partner_bad, issue.content_object)
def test_run_all_checks(self):
PartnerFactory(short_name='A name') # make a good one as well just to ensure it's not flagging everything
partner_bad = PartnerFactory()
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertEqual(1, FlaggedIssue.objects.count())
issue = FlaggedIssue.objects.first()
self.assertEqual(PartnersMustHaveShortNameTestCheck.check_id, issue.issue_id)
self.assertEqual(partner_bad, issue.content_object)
def test_no_issue(self):
"""Check that if agreement has signed amendment
then issue is NOT raised
"""
amendment = AgreementAmendmentFactory(signed_amendment="random.pdf")
self.assertTrue(amendment.signed_amendment)
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_no_issue(self):
"""Check that if agreement has signed amendment
then issue is NOT raised
"""
amendment = AgreementAmendmentFactory(signed_amendment="random.pdf")
self.assertTrue(amendment.signed_amendment)
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_no_amendment_file(self):
"""Check that if no amendment file, then issue is raised"""
amendment = InterventionAmendmentFactory(signed_amendment=None)
self.assertFalse(amendment.signed_amendment)
self.assertFalse(self.qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertTrue(self.qs_issue.exists())
issue = self.qs_issue.first()
self.assertIn("has missing amendment file", issue.message)
def test_no_amendment_file(self):
"""Check that if no amendment file, then issue is raised"""
amendment = InterventionAmendmentFactory(signed_amendment=None)
self.assertFalse(amendment.signed_amendment)
self.assertFalse(self.qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertTrue(self.qs_issue.exists())
issue = self.qs_issue.first()
self.assertIn("has missing amendment file", issue.message)
def test_no_issue(self):
"""Check if intervention does not fail validation,
no issue is raised
"""
intervention = InterventionFactory()
validator = InterventionValid(intervention, self.master_user)
self.assertTrue(validator.is_valid)
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_no_issue(self):
"""Check if intervention does not fail validation,
no issue is raised
"""
intervention = InterventionFactory()
validator = InterventionValid(intervention, self.master_user)
self.assertTrue(validator.is_valid)
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_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_invalid_intervention(self):
"""Check if intervention fails validation, issue is raised"""
intervention = InterventionFactory(
signed_by_unicef_date=datetime.date(2001, 2, 1),
signed_by_partner_date=datetime.date(2001, 3, 1),
signed_pd_document="random.pdf",
start=datetime.date(2001, 1, 1))
validator = InterventionValid(intervention, self.master_user)
self.assertFalse(validator.is_valid)
self.assertFalse(self.qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertTrue(self.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_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_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_issue_found(self):
"""Check that if no attached agreement, then an issue is raised"""
qs_issue = FlaggedIssue.objects.filter(
issue_id="active_pca_no_signed_doc")
agreement = AgreementFactory(attached_agreement=None)
self.assertFalse(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.assertTrue(qs_issue.exists())
issue = qs_issue.first()
self.assertIn("does not have a signed PCA attached", issue.message)
def test_invalid_intervention(self):
"""Check if intervention fails validation, issue is raised"""
intervention = InterventionFactory(
signed_by_unicef_date=datetime.date(2001, 2, 1),
signed_by_partner_date=datetime.date(2001, 3, 1),
signed_pd_document="random.pdf",
start=datetime.date(2001, 1, 1)
)
validator = InterventionValid(intervention, self.master_user)
self.assertFalse(validator.is_valid)
self.assertFalse(self.qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertTrue(self.qs_issue.exists())
def test_recheck_with_metadata(self):
partner_bad = PartnerFactory(name='bar')
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertEqual(1, FlaggedIssue.objects.count())
issue = FlaggedIssue.objects.first()
self.assertEqual(PartnersNameMustBeFooTestCheck.check_id, issue.issue_id)
self.assertEqual(partner_bad, issue.content_object)
self.assertEqual(ISSUE_STATUS_NEW, issue.issue_status)
partner_bad.name = 'foo'
partner_bad.save()
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_RESOLVED, issue.issue_status)
def test_document_type_ssfa(self):
"""Check that if agreement type PCA but document type SSFA
then issue is raised
"""
agreement = AgreementFactory(agreement_type=Agreement.PCA)
InterventionFactory(
agreement=agreement,
document_type=Intervention.SSFA,
)
self.assertFalse(self.qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertTrue(self.qs_issue.exists())
issue = self.qs_issue.first()
self.assertIn("type {}".format(Intervention.SSFA), issue.message)
def test_recheck_with_metadata(self):
partner_bad = PartnerFactory(name='bar')
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertEqual(1, FlaggedIssue.objects.count())
issue = FlaggedIssue.objects.first()
self.assertEqual(PartnersNameMustBeFooTestCheck.check_id, issue.issue_id)
self.assertEqual(partner_bad, issue.content_object)
self.assertEqual(ISSUE_STATUS_NEW, issue.issue_status)
partner_bad.name = 'foo'
partner_bad.save()
issue = FlaggedIssue.objects.get(pk=issue.pk)
issue.recheck()
self.assertEqual(ISSUE_STATUS_RESOLVED, issue.issue_status)
def test_issue_found(self):
"""Check that if no attached agreement, then an issue is raised"""
qs_issue = FlaggedIssue.objects.filter(
issue_id="active_pca_no_signed_doc"
)
agreement = AgreementFactory(attached_agreement=None)
self.assertFalse(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.assertTrue(qs_issue.exists())
issue = qs_issue.first()
self.assertIn("does not have a signed PCA attached", issue.message)
def test_document_type_ssfa(self):
"""Check that if agreement type PCA but document type SSFA
then issue is raised
"""
agreement = AgreementFactory(agreement_type=Agreement.PCA)
InterventionFactory(
agreement=agreement,
document_type=Intervention.SSFA,
)
self.assertFalse(self.qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertTrue(self.qs_issue.exists())
issue = self.qs_issue.first()
self.assertIn("type {}".format(Intervention.SSFA), issue.message)
def test_no_country_programme(self):
"""Check that if intervention has no country programme
the intervention is ignored during the check
"""
qs_issue = FlaggedIssue.objects.filter(issue_id="pd_outputs_wrong")
intervention = InterventionFactory()
result = ResultFactory(country_programme=CountryProgrammeFactory())
InterventionResultLink.objects.create(
intervention=intervention,
cp_output=result,
)
self.assertIsNone(intervention.country_programme)
self.assertNotEqual(intervention.country_programme,
result.country_programme)
self.assertFalse(qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertFalse(qs_issue.exists())
def test_no_country_programme(self):
"""Check that if intervention has no country programme
the intervention is ignored during the check
"""
qs_issue = FlaggedIssue.objects.filter(
issue_id="pd_outputs_wrong"
)
intervention = InterventionFactory()
result = ResultFactory(country_programme=CountryProgrammeFactory())
InterventionResultLink.objects.create(
intervention=intervention,
cp_output=result,
)
self.assertIsNone(intervention.country_programme)
self.assertNotEqual(
intervention.country_programme,
result.country_programme
)
self.assertFalse(qs_issue.exists())
checks.bootstrap_checks(default_is_active=True)
checks.run_all_checks()
self.assertFalse(qs_issue.exists())
def test_missing_model(self):
with self.assertRaisesRegexp(ImproperlyConfigured,
"Issue checks must define a model class"):
checks.run_all_checks()
def test_missing_check_id(self):
with self.assertRaisesRegexp(ImproperlyConfigured,
"Issue checks must define a unique ID!"):
checks.run_all_checks()
def handle(self, *args, **options):
run_all_checks()
def test_missing_run_check(self):
with self.assertRaisesRegexp(TypeError,
"with abstract methods run_check"):
checks.run_all_checks()
def run_all_checks_task():
"""
Run all configured IssueChecks against the entire database.
"""
run_all_checks()
def test_missing_check_id(self):
with self.assertRaisesRegexp(ImproperlyConfigured, "Issue checks must define a unique ID!"):
checks.run_all_checks()
def test_missing_model(self):
with self.assertRaisesRegexp(ImproperlyConfigured, "Issue checks must define a model class"):
checks.run_all_checks()
def test_missing_run_check(self):
with self.assertRaisesRegexp(TypeError, "with abstract methods run_check"):
checks.run_all_checks()
def run_all_checks_task():
"""
Run all configured IssueChecks against the entire database.
"""
run_all_checks()
