def test_active_country_gets_program(self):
active_country = w_factories.CountryFactory(
country="Active",
code="AT",
)
inactive_country = w_factories.CountryFactory(country="Inactive",
code="IT")
country_access_active = w_factories.CountryAccessFactory(
country=active_country, tolauser=self.tola_user)
country_access_inactive = w_factories.CountryAccessFactory(
country=inactive_country, tolauser=self.tola_user)
self.tola_user.countryaccess_set.add(country_access_active,
country_access_inactive)
self.tola_user.active_country = active_country
self.tola_user.save()
active_program = w_factories.ProgramFactory(funding_status="Funded", )
active_program.country.set([active_country])
inactive_program = w_factories.ProgramFactory(funding_status="Funded")
inactive_program.country.clear()
inactive_program.country.set([inactive_country])
response = self.client.get('/')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.context['programs']), 1)
self.assertEqual(response.context['programs'][0].id, active_program.id)
# test selected country overrides:
response = self.client.get('/{pk}/'.format(pk=inactive_country.id))
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.context['programs']), 1)
self.assertEqual(response.context['programs'][0].id,
inactive_program.id)
self.tola_user.refresh_from_db()
self.assertEqual(self.tola_user.active_country, inactive_country)
def setUp(self):
for _ in range(10):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2014, 1, 1),
reporting_period_end=datetime.date(2014, 12, 31))
for _ in range(5):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=100,
program=program)
i_factories.CollectedDataFactory(indicator=indicator,
achieved=105)
for _ in range(5):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=100,
program=program)
evidence = w_factories.DocumentationFactory(program=program)
i_factories.CollectedDataFactory(indicator=indicator,
achieved=50,
evidence=evidence)
for _ in range(2):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP, program=program)
for _ in range(4):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.MID_END, program=program)
for sort in range(2):
i_factories.PeriodicTargetFactory(
indicator=indicator,
target=40,
start_date=datetime.date(2014, 5, 1),
end_date=datetime.date(2014, 8, 1),
customsort=sort)
def test_program_with_multiple_indicators_returns_correct_date(self):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2015, 12, 31)
)
indicator1 = i_factories.IndicatorFactory(
target_frequency=Indicator.ANNUAL,
program=program
)
i_factories.PeriodicTargetFactory(
indicator=indicator1,
start_date=datetime.date(2015, 1, 1),
end_date=datetime.date(2015, 12, 31)
)
indicator2 = i_factories.IndicatorFactory(
target_frequency=Indicator.TRI_ANNUAL,
program=program
)
for start, end in [(datetime.date(2015, 1, 1), datetime.date(2015, 4, 30)),
(datetime.date(2015, 5, 1), datetime.date(2015, 8, 31)),
(datetime.date(2015, 9, 1), datetime.date(2015, 12, 31))]:
i_factories.PeriodicTargetFactory(
indicator=indicator2,
start_date=start,
end_date=end
)
self.assertEqual(program.last_time_aware_indicator_start_date, datetime.date(2015, 9, 1))
def setUp(self):
program = w_factory.ProgramFactory()
self.expected = []
for x in reversed(['1', '1.1.1', '2.1.2', '3', '3.2.1.1', '10.1', '1.1a', '1.1b', '1.2a']):
self.expected.append(get_indicator(x, program).id)
self.expected = reversed(self.expected)
self.program_id = program.id
def setUp(self):
program = w_factory.ProgramFactory()
self.expected = []
for x in reversed(range(10)):
self.expected.append(get_indicator(x+1, program).id)
self.expected = reversed(self.expected)
self.program_id = program.id
def test_reporting_period_bad_both_shows_incorrect(self):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 15),
reporting_period_end=datetime.date(2017, 2, 15)
)
homepage_program = ProgramWithMetrics.home_page.with_annotations().get(pk=program.pk)
self.assertFalse(homepage_program.reporting_period_correct)
def test_time_aware_indicators_no_completed_periods(self):
# if program started yesterday then no targets will be finished by today:
today = datetime.date.today() - datetime.timedelta(days=1)
self.program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(today.year, today.month, 1),
reporting_period_end=datetime.date(today.year + 1, today.month,
1) - datetime.timedelta(days=1))
for frequency in [
freq for freq in self.TIME_AWARE_FREQUENCIES
if freq != Indicator.MONTHLY
]:
# the above hack due to a once-a-month inability to make a period that hasn't finished a month
# relative to today. The alternative is monkey-patching mysql's NOW function, which seems bad
self.load_base_indicator()
self.indicator.target_frequency = frequency
self.indicator.save()
self.load_targets()
self.load_data(date=datetime.date.today() -
datetime.timedelta(days=1))
indicator = self.get_annotated_indicator()
self.assertFalse(indicator.reporting)
for target in self.targets:
target.delete()
self.targets = []
self.indicator.delete()
self.indicator = None
def setUp(self):
program = w_factory.ProgramFactory()
self.expected = []
for x in reversed(['aasdf', 'basdf', 'casdf', 'daasdf', 'e3214', 'f5235']):
self.expected.append(get_indicator(x, program).id)
self.expected = reversed(self.expected)
self.program_id = program.id
def setUp(self):
self.program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2016, 10, 1),
reporting_period_end=datetime.date(2017, 9, 30))
self.indicator = i_factories.IndicatorFactory(program=self.program)
self.targets = []
self.data = []
def setUpTestData(cls):
program = w_factories.ProgramFactory(
funding_status="funded",
name="Test program name",
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2017, 12, 31),
_using_results_framework=Program.MIGRATED,
auto_number_indicators=True
)
i_factories.LevelTierFactory(
program=program,
tier_depth=1,
name="Test Tier 1"
)
i_factories.LevelTierFactory(
program=program,
tier_depth=2,
name="Test Tier 2"
)
level = i_factories.LevelFactory(
program=program,
name="Test Output Level",
customsort=1,
parent=i_factories.LevelFactory(
name="Test Goal Level",
program=program,
customsort=1,
parent=None,
),
assumptions=', '.join(['assuming']*10)
)
indicators = [
i_factories.IndicatorFactory(
pk=21,
program=program,
level=level,
level_order=0,
means_of_verification=None,
number="1.23a"
),
i_factories.IndicatorFactory(
pk=22,
program=program,
level=level,
level_order=1,
means_of_verification="some means here",
number="2.444ab"
),
i_factories.IndicatorFactory(
pk=23,
program=program,
level=None,
level_order=1,
means_of_verification=', '.join(["some means here"]*10),
number="4.444asdf"
)
]
cls.program = program
cls.level = level
cls.indicators = indicators
def test_time_aware_indicators_no_completed_periods(self):
# if program started yesterday then no targets will be finished by today:
today = datetime.date.today() - datetime.timedelta(days=1)
self.program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(today.year, today.month, 1),
reporting_period_end=datetime.date(today.year+1, today.month, 1) - datetime.timedelta(days=1)
)
for frequency in [freq for freq in self.TIME_AWARE_FREQUENCIES if freq != Indicator.MONTHLY]:
# the above hack brought to you by the fact that once a month it is impossible to make a monthly indicator
# with no completed programs. I apologize.
self.load_base_indicator()
self.indicator.target_frequency = frequency
self.indicator.save()
self.load_targets()
self.load_data(date=datetime.date.today()-datetime.timedelta(days=1))
program = self.get_annotated_program()
self.assertEqual(
program.scope_counts['nonreporting_count'], 1,
'{frequency} frequency indicator got scope counts {sc} instead of 1 nonreporting'.format(
frequency=frequency,
sc=program.scope_counts
))
for target in self.targets:
target.delete()
self.targets = []
self.indicator.delete()
self.indicator = None
def test_end_date_will_change_to_after_last_time_aware_target_set(self):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2017, 12, 31)
)
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.ANNUAL,
program=program
)
for start, end in [(datetime.date(2015, 1, 1), datetime.date(2015, 12, 31)),
(datetime.date(2016, 1, 1), datetime.date(2016, 12, 31)),
(datetime.date(2017, 1, 1), datetime.date(2017, 12, 31))]:
i_factories.PeriodicTargetFactory(
start_date=start,
end_date=end,
indicator=indicator
)
response = self.client.post(reverse('reportingperiod_update', kwargs={'pk': program.pk}),
{'reporting_period_start': '2015-01-01',
'reporting_period_end': '2017-10-31',
'rationale': 'test'})
self.assertEqual(json.loads(response.content)['msg'], 'success')
self.assertEqual(len(json.loads(response.content)['failmsg']), 0)
self.assertEqual(response.status_code, 200)
refreshed = Program.objects.get(pk=program.pk)
self.assertEqual(refreshed.reporting_period_start, datetime.date(2015, 1, 1))
self.assertEqual(refreshed.reporting_period_end, datetime.date(2017, 10, 31))
def test_start_date_does_change_if_no_time_aware_target_set(self):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2017, 12, 31)
)
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.MID_END,
program=program
)
i_factories.PeriodicTargetFactory(
start_date=None,
end_date=None,
customsort=0,
indicator=indicator
)
response = self.client.post(reverse('reportingperiod_update', kwargs={'pk': program.pk}),
{'reporting_period_start': '2016-01-01',
'reporting_period_end': '2017-12-31',
'rationale': 'test'})
self.assertEqual(json.loads(response.content)['msg'], 'success')
self.assertEqual(len(json.loads(response.content)['failmsg']), 0)
self.assertEqual(response.status_code, 200)
refreshed = Program.objects.get(pk=program.pk)
self.assertEqual(refreshed.reporting_period_start, datetime.date(2016, 1, 1))
self.assertEqual(refreshed.reporting_period_end, datetime.date(2017, 12, 31))
def test_start_date_to_reporting_date(self):
program = w_factories.ProgramFactory(
start_date=datetime.date(2018, 6, 15),
end_date=datetime.date(2019, 12, 14)
)
reporting_dates = util.get_reporting_dates(program)
self.assertEqual(reporting_dates['reporting_period_start'], datetime.date(2018, 6, 1))
self.assertEqual(reporting_dates['reporting_period_end'], datetime.date(2019, 12, 31))
def setUp(self):
self.user = w_factories.TolaUserFactory()
self.client = test.Client()
self.client.force_login(self.user.user)
self.response = None
self.program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2017, 2, 1),
reporting_period_end=datetime.date(2019, 10, 31))
def test_program_with_non_time_aware_indicators_returns_none(self):
for frequency in [Indicator.LOP, Indicator.MID_END, Indicator.EVENT]:
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2017, 12, 31)
)
i_factories.IndicatorFactory(
target_frequency=frequency,
program=program
)
self.assertIsNone(program.last_time_aware_indicator_start_date)
def get_programs_for_country(country):
two_indicator_program = w_factories.ProgramFactory(
funding_status="Funded",
reporting_period_start=start_date,
reporting_period_end=end_date)
two_indicator_program.country.set([country])
one_indicator_program = w_factories.ProgramFactory(
funding_status="Funded",
reporting_period_start=start_date,
reporting_period_end=end_date)
one_indicator_program.country.set([country])
zero_indicator_program = w_factories.ProgramFactory(
funding_status="Funded",
reporting_period_start=start_date,
reporting_period_end=end_date)
zero_indicator_program.country.set([country])
i_factories.IndicatorFactory(program=two_indicator_program)
i_factories.IndicatorFactory(program=two_indicator_program)
i_factories.IndicatorFactory(program=one_indicator_program)
return two_indicator_program.id, one_indicator_program.id, zero_indicator_program.id
def test_program_with_all_indicators_returns_true(self):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2017, 12, 31)
)
for frequency, _ in Indicator.TARGET_FREQUENCIES:
i_factories.IndicatorFactory(
target_frequency=frequency,
program=program
)
self.assertTrue(program.has_time_aware_targets)
def test_various_end_date_conversions(self):
for end, reporting in [
(datetime.date(2014, 1, 1), datetime.date(2014, 1, 31)),
(datetime.date(2015, 10, 13), datetime.date(2015, 10, 31)),
(datetime.date(2016, 10, 30), datetime.date(2016, 10, 31)),
(datetime.date(2017, 12, 31), datetime.date(2017, 12, 31))
]:
program = w_factories.ProgramFactory(
start_date=datetime.date(2013, 1, 1),
end_date=end
)
reporting_dates = util.get_reporting_dates(program)
self.assertEqual(reporting_dates['reporting_period_end'], reporting)
def test_reporting_period_updates_with_good_both_data(self):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2017, 12, 31)
)
response = self.client.post(reverse('reportingperiod_update', kwargs={'pk': program.pk}),
{'reporting_period_start': '2014-02-01',
'reporting_period_end': '2018-10-31'})
self.assertEqual(json.loads(response.content)['msg'], 'success')
self.assertEqual(response.status_code, 200)
refreshed = Program.objects.get(pk=program.pk)
self.assertEqual(refreshed.reporting_period_start, datetime.date(2014, 2, 1))
self.assertEqual(refreshed.reporting_period_end, datetime.date(2018, 10, 31))
def test_reporting_period_does_not_update_with_bad_end_data(self):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2015, 1, 1),
reporting_period_end=datetime.date(2017, 12, 31)
)
response = self.client.post(reverse('reportingperiod_update', kwargs={'pk': program.pk}),
{'reporting_period_start': '2015-01-01',
'reporting_period_end': '2017-10-15'})
self.assertEqual(json.loads(response.content)['msg'], 'fail')
self.assertEqual(len(json.loads(response.content)['failmsg']), 1)
self.assertEqual(response.status_code, 422)
refreshed = Program.objects.get(pk=program.pk)
self.assertEqual(refreshed.reporting_period_start, datetime.date(2015, 1, 1))
self.assertEqual(refreshed.reporting_period_end, datetime.date(2017, 12, 31))
def test_lop_indicator_in_open_program(self):
# get open (reporting period not over) program:
# set dates from today so test doesn't become obsolete at some arbitrary future date:
start_date = datetime.date.today() - datetime.timedelta(days=10)
end_date = datetime.date.today() + datetime.timedelta(days=100)
self.program = w_factories.ProgramFactory(
reporting_period_start=start_date, reporting_period_end=end_date)
self.load_base_indicator()
self.indicator.target_frequency = Indicator.LOP
# lop_target and data should be set to ensure it's only program openness restricting from "complete"
self.indicator.lop_target = 1000
self.indicator.save()
self.load_data()
indicator = self.get_annotated_indicator()
self.assertFalse(indicator.reporting)
def setUp(self):
self.program = w_factories.ProgramFactory(
reporting_period_start=datetime.date.today() -
datetime.timedelta(days=365),
reporting_period_end=datetime.date.today() -
datetime.timedelta(days=1))
self.indicators = []
self.data = []
self.targets = []
self.indicators.extend(self.get_on_target_indicators())
self.indicators.extend(self.get_undertarget_indicators())
self.indicators.extend(self.get_overtarget_indicators())
self.indicators.extend(self.get_nonreporting_indicators())
with self.assertNumQueries(2):
self.reporting_program = ProgramWithMetrics.home_page.with_annotations(
'scope').get(pk=self.program.id)
def setUp(self):
self.program = w_factories.ProgramFactory()
self.indicator = i_factories.IndicatorFactory(
program=self.program, target_frequency=Indicator.ANNUAL)
self.result = i_factories.ResultFactory(indicator=self.indicator, )
self.result.record_name = 'record name'
self.result.evidence_url = 'evidence url'
self.blank_result = i_factories.ResultFactory(indicator=self.indicator)
self.tola_user = w_factories.TolaUserFactory()
self.user = self.tola_user.user
self.request = type('Request', (object, ), {
'has_write_access': True,
'user': self.user
})()
def setUp(self):
self.program = w_factories.ProgramFactory()
self.indicator = i_factories.IndicatorFactory(program=self.program)
self.result = i_factories.ResultFactory(indicator=self.indicator)
self.user = w_factories.UserFactory(first_name="FN",
last_name="LN",
username="******",
is_superuser=True)
self.user.set_password('password')
self.user.save()
self.tola_user = w_factories.TolaUserFactory(user=self.user)
self.tola_user.save()
self.client = test.Client(enforce_csrf_checks=False)
self.client.login(username='******', password='******')
def setUp(self):
for _ in range(10):
program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2014, 1, 1),
reporting_period_end=datetime.date(2014, 12, 31))
for _ in range(5):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=100,
program=program)
target = i_factories.PeriodicTargetFactory(
indicator=indicator,
target=indicator.lop_target,
start_date=indicator.program.reporting_period_start,
end_date=indicator.program.reporting_period_end)
i_factories.ResultFactory(indicator=indicator,
periodic_target=target,
achieved=105)
for _ in range(5):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=100,
program=program)
target = i_factories.PeriodicTargetFactory(
indicator=indicator,
target=indicator.lop_target,
start_date=indicator.program.reporting_period_start,
end_date=indicator.program.reporting_period_end)
i_factories.ResultFactory(
indicator=indicator,
periodic_target=target,
achieved=50,
evidence_url='http://test_evidence_url')
for _ in range(2):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP, program=program)
for _ in range(4):
indicator = i_factories.IndicatorFactory(
target_frequency=Indicator.MID_END, program=program)
for sort in range(2):
i_factories.PeriodicTargetFactory(
indicator=indicator,
target=40,
start_date=datetime.date(2014, 5, 1),
end_date=datetime.date(2014, 8, 1),
customsort=sort)
def setUp(self):
self.program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2016, 1, 1),
reporting_period_end=datetime.date(2016, 12, 31),
)
self.indicator = i_factories.IndicatorFactory(
program=self.program, target_frequency=Indicator.LOP)
self.tola_user = w_factories.TolaUserFactory()
self.user = self.tola_user.user
self.request = type('Request', (object, ), {
'has_write_access': True,
'user': self.user
})()
self.form_kwargs = {
'user': self.user,
'indicator': self.indicator,
'program': self.program,
'request': self.request,
}
def setUpTestData(cls):
cls.country = w_factories.CountryFactory()
cls.user = w_factories.TolaUserFactory()
cls.user.countries.add(cls.country)
for case in cls.expected_cases:
program = w_factories.ProgramFactory(
reporting_period_start=cls.program_start_date,
reporting_period_end=cls.program_end_date,
funding_status='Funded',
name=case['name'])
program.country.add(cls.country)
for c in range(case['indicator_count']):
data_count = 0
indicator = do_add_indicator(program)
if c < case['targets_defined']:
do_add_defined_target(indicator)
if c < case['reported_results']:
collect_date = cls.collect_date + datetime.timedelta(
days=data_count)
data_count += 1
result = do_add_reported_result(indicator, collect_date,
program)
if c < case['results_evidence']:
do_add_evidence(result, program)
def get_closed_program(self):
self.program = w_factories.ProgramFactory(
reporting_period_start=datetime.date(2016, 1, 1),
reporting_period_end=datetime.date(2016, 12, 31)
)
def get_program(self):
return w_factories.ProgramFactory(
reporting_period_start=self.program_dates[0],
reporting_period_end=self.program_dates[1])
