def get_indicators(self):
for c, kwargs in enumerate(self.indicator_kwargs):
indicator = i_factories.IndicatorFactory(program=self.program,
number=c,
**kwargs['indicator'])
for target_kwargs, period in zip(kwargs['targets'],
self.program.get_periods_for_frequency(indicator.target_frequency)):
target = i_factories.PeriodicTargetFactory(
indicator=indicator,
target=target_kwargs['target'],
start_date=period['start'],
end_date=period['end'],
customsort=period['customsort']
)
for date_collected, achieved in target_kwargs['results']:
i_factories.ResultFactory(
periodic_target=target,
indicator=indicator,
date_collected=date_collected,
achieved=achieved
)
for date_collected, achieved in kwargs['results']:
i_factories.ResultFactory(
indicator=indicator,
date_collected=date_collected,
achieved=achieved
)
def setUp(self):
program = get_open_program()
indicator = i_factories.IndicatorFactory(
program=program,
target_frequency=Indicator.MID_END,
unit_of_measure_type=Indicator.PERCENTAGE,
lop_target=60)
targets = [
i_factories.PeriodicTargetFactory(indicator=indicator,
customsort=0,
start_date=None,
end_date=None,
target=80),
i_factories.PeriodicTargetFactory(indicator=indicator,
customsort=1,
start_date=None,
end_date=None,
target=65)
]
results = [
i_factories.ResultFactory(indicator=indicator,
periodic_target=targets[0],
date_collected=datetime.date(2018, 1, 1),
achieved=75),
i_factories.ResultFactory(indicator=indicator,
periodic_target=targets[0],
date_collected=datetime.date(2018, 2, 1),
achieved=70)
]
self.results_indicator = ResultsIndicator.results_view.get(
pk=indicator.pk)
self.metrics_indicator = MetricsIndicator.objects.with_annotations(
'scope').get(pk=indicator.pk)
def test_lop_and_midend_just_mid_reporting(self):
self.get_closed_program()
indicator_lop = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=1000,
program=self.program)
lop_target = i_factories.PeriodicTargetFactory(
indicator=indicator_lop,
target=1000,
start_date=self.program.reporting_period_start,
end_date=self.program.reporting_period_end)
lop_data = i_factories.ResultFactory(
indicator=indicator_lop,
periodic_target=lop_target,
achieved=400,
date_collected=self.program.reporting_period_end -
datetime.timedelta(days=10))
indicator_midend = i_factories.IndicatorFactory(
target_frequency=Indicator.MID_END, program=self.program)
mid_target = i_factories.PeriodicTargetFactory(
indicator=indicator_midend,
period=PeriodicTarget.MIDLINE,
target=1000)
mid_data = i_factories.ResultFactory(
indicator=indicator_midend,
periodic_target=mid_target,
achieved=400,
date_collected=self.program.reporting_period_start +
datetime.timedelta(days=20))
for indicator in MetricsIndicator.objects.with_annotations(
'reporting').all():
self.assertTrue(indicator.reporting)
def add_results(self):
self.result_out_of_country = i_factories.ResultFactory(
indicator=self.indicator_out_of_country,
program=self.program_out_of_country,
achieved=100)
self.result_in_country = i_factories.ResultFactory(
indicator=self.indicator_in_country,
program=self.program_in_country,
achieved=100)
def get_on_target_indicators(self):
# lop indicator on target to lop target value
lop_indicator = self.get_base_indicator()
lop_indicator.target_frequency = Indicator.LOP
lop_indicator.lop_target = 10000
lop_indicator.is_cumulative = False
lop_indicator.unit_of_measure_type = Indicator.NUMBER
lop_indicator.save()
lop_pt = i_factories.PeriodicTargetFactory(
indicator=lop_indicator,
target=lop_indicator.lop_target,
start_date=lop_indicator.program.reporting_period_start,
end_date=lop_indicator.program.reporting_period_end)
lop_data = self.get_base_data(lop_indicator)
lop_data.achieved = 10000
lop_data.periodic_target = lop_pt
lop_data.save()
self.data.append(lop_data)
# semi annual indicator with target and valid data
time_indicator = self.get_base_indicator()
time_indicator.target_frequency = Indicator.SEMI_ANNUAL
time_indicator.is_cumulative = True
time_indicator.unit_of_measure_type = Indicator.NUMBER
time_indicator.save()
start_date = self.program.reporting_period_start
mid_date = datetime.date(
start_date.year + 1 if start_date.month > 6 else start_date.year,
start_date.month -
6 if start_date.month > 6 else start_date.month + 6,
start_date.day)
time_target_1 = i_factories.PeriodicTargetFactory(
indicator=time_indicator,
target=400,
start_date=start_date,
end_date=mid_date - datetime.timedelta(days=1))
time_target_2 = i_factories.PeriodicTargetFactory(
indicator=time_indicator,
target=600,
start_date=mid_date,
end_date=self.program.reporting_period_end)
self.targets.extend([time_target_1, time_target_2])
data_1 = i_factories.ResultFactory(
indicator=time_indicator,
periodic_target=time_target_1,
date_collected=time_target_1.start_date +
datetime.timedelta(days=2),
achieved=200)
data_2 = i_factories.ResultFactory(
indicator=time_indicator,
periodic_target=time_target_2,
date_collected=time_target_2.start_date +
datetime.timedelta(days=2),
achieved=400)
self.data.extend([data_1, data_2])
return [lop_indicator, time_indicator]
def test_midend_target_sums_midend_with_both_data(self):
self.indicator.target_frequency = Indicator.MID_END
self.indicator.save()
mid_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=500,
period=PeriodicTarget.MIDLINE,
customsort=0)
end_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=800,
period=PeriodicTarget.ENDLINE,
customsort=1)
self.targets.extend([mid_target, end_target])
mid_data = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=mid_target,
achieved=350,
date_collected=self.program.reporting_period_start +
datetime.timedelta(days=1))
end_data = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=end_target,
achieved=950,
date_collected=self.program.reporting_period_start +
datetime.timedelta(days=10))
self.data.extend([mid_data, end_data])
program = ProgramWithMetrics.home_page.with_annotations('scope').get(
pk=self.program.id)
self.assertEqual(
program.scope_counts['on_scope'], 1,
"should show overunder as 0 (in range), got {0}".format(
program.scope_counts))
self.indicator.is_cumulative = True
self.indicator.save()
program = ProgramWithMetrics.home_page.with_annotations('scope').get(
pk=self.program.id)
# both have data, set to cumulative, so should show latest (endline) target:
self.assertEqual(
program.scope_counts['high'], 1,
"should show overunder as 1 (over range), got {0}".format(
program.scope_counts))
self.indicator.direction_of_change = Indicator.DIRECTION_OF_CHANGE_NEGATIVE
self.indicator.save()
program = ProgramWithMetrics.home_page.with_annotations('scope').get(
pk=self.program.id)
self.assertEqual(
program.scope_counts['low'], 1,
"should show overunder as -1 (under range - negative DOC), got {0}"
.format(program.scope_counts))
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 get_base_data(self, indicator, target=None):
data = i_factories.ResultFactory(
indicator=indicator,
periodic_target=target,
date_collected=self.program.reporting_period_start +
datetime.timedelta(days=10))
return data
def test_midend_doesnt_sum_if_no_endline_data(self):
self.indicator.target_frequency = Indicator.MID_END
self.indicator.save()
mid_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=500,
period=PeriodicTarget.MIDLINE,
customsort=0)
end_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=800,
period=PeriodicTarget.ENDLINE,
customsort=1)
self.targets.extend([mid_target, end_target])
mid_data = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=mid_target,
achieved=350,
date_collected=self.program.reporting_period_start +
datetime.timedelta(days=1))
self.data.append(mid_data)
program = ProgramWithMetrics.home_page.with_annotations('scope').get(
pk=self.program.id)
self.assertEqual(
program.scope_counts['low'], 1,
"should show under (350/500), got {0}".format(
program.scope_counts))
self.indicator.direction_of_change = Indicator.DIRECTION_OF_CHANGE_NEGATIVE
self.indicator.save()
program = ProgramWithMetrics.home_page.with_annotations('scope').get(
pk=self.program.id)
self.assertEqual(
program.scope_counts['high'], 1,
"should show over (350/500), got {0}".format(program.scope_counts))
def get_targets(self):
targets = []
results = []
start_date = self.program_dates[0]
end_date = self.program_dates[1]
next_date = self.next_date_func(start_date)
counter = 0
while start_date < end_date:
target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
start_date=start_date,
end_date=next_date - datetime.timedelta(days=1),
target=self.target_values[counter])
targets.append(target)
if counter < len(self.result_values):
results.append(
i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=target,
date_collected=start_date + datetime.timedelta(days=1),
achieved=self.result_values[counter]))
counter += 1
start_date = next_date
next_date = self.next_date_func(start_date)
return targets, results
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 add_results_for_targets(targets, values):
results = []
for c, value in enumerate(values):
results.append(
i_factories.ResultFactory(indicator=targets[c].indicator,
periodic_target=targets[c],
date_collected=targets[c].start_date,
achieved=value))
return results
def add_result(self, value, indicator=None):
indicator = self.indicator if indicator is None else indicator
date_collected = self.program.reporting_period_start + datetime.timedelta(
days=len(self.data[indicator.pk]))
data = i_factories.ResultFactory(indicator=indicator,
achieved=value,
date_collected=date_collected)
self.data[indicator.pk].append(data)
return data
def add_data(self, indicator=None, target=None):
data = i_factories.ResultFactory(
indicator=indicator,
periodic_target=target,
date_collected=self.program.reporting_period_start +
datetime.timedelta(days=3 + 2 * len(self.data)),
achieved=100)
self.data.append(data)
return data
def load_data(self, indicator=None, achieved=None, date=None, target=None):
"""adds data to the indicator"""
indicator = self.indicator if indicator is None else indicator
achieved = 800 if achieved is None else achieved
date = self.program.reporting_period_start + datetime.timedelta(
days=5) if date is None else date
datum = i_factories.ResultFactory(indicator=indicator,
achieved=achieved,
date_collected=date,
periodic_target=target)
self.data.append(datum)
def add_results(self, indicator, targets, result_values):
data = []
for target, result_value_set in zip(targets, result_values):
collect_date = target.start_date
for c, result_value in enumerate(result_value_set):
data.append(
i_factories.ResultFactory(achieved=result_value,
periodic_target=target,
indicator=indicator,
date_collected=collect_date +
datetime.timedelta(days=c)))
return data
def test_midend_doesnt_sum_if_no_endline_data(self):
self.indicator.target_frequency = Indicator.MID_END
self.indicator.save()
mid_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=500,
period=PeriodicTarget.MIDLINE,
customsort=0
)
end_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=800,
period=PeriodicTarget.ENDLINE,
customsort=1
)
self.targets.extend([mid_target, end_target])
mid_data = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=mid_target,
achieved=350,
date_collected=self.program.reporting_period_start + datetime.timedelta(days=1)
)
self.data.append(mid_data)
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
# both have data, defaults to non_cumulative, so should show sum of both targets:
self.assertEqual(
indicator.lop_target_progress, 500,
"should not sum targets (no data for endline) expecting 500, got {0}".format(indicator.lop_target_progress)
)
self.assertEqual(
indicator.lop_actual_progress, 350,
"should show only data, 350 got {0}".format(indicator.lop_actual_progress)
)
self.assertEqual(
indicator.over_under, -1,
"should show under (350/500), got {0}".format(indicator.over_under)
)
self.indicator.direction_of_change = Indicator.DIRECTION_OF_CHANGE_NEGATIVE
self.indicator.save()
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
self.assertEqual(
indicator.over_under, 1,
"should show over (350/500), got {0}".format(indicator.over_under)
)
self.indicator.is_cumulative = True
self.indicator.save()
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
self.assertEqual(
indicator.lop_target_progress, 500,
"should not take endline target (no data`) expecting 500, got {0}".format(indicator.lop_target_progress)
)
def test_lop_and_midend_just_mid_reporting(self):
self.get_closed_program()
indicator_lop = i_factories.IndicatorFactory(
target_frequency=Indicator.LOP,
lop_target=1000,
program=self.program
)
i_lop_target = i_factories.PeriodicTargetFactory(
indicator=indicator_lop,
target=indicator_lop.lop_target,
start_date=self.program.reporting_period_start,
end_date=self.program.reporting_period_end
)
lop_data = i_factories.ResultFactory(
indicator=indicator_lop,
periodic_target=i_lop_target,
achieved=400,
date_collected=self.program.reporting_period_end - datetime.timedelta(days=10)
)
indicator_midend = i_factories.IndicatorFactory(
target_frequency=Indicator.MID_END,
program=self.program
)
mid_target = i_factories.PeriodicTargetFactory(
indicator=indicator_midend,
period=PeriodicTarget.MIDLINE,
target=1000
)
mid_data = i_factories.ResultFactory(
indicator=indicator_midend,
periodic_target=mid_target,
achieved=400,
date_collected=self.program.reporting_period_start + datetime.timedelta(days=20)
)
program = self.get_annotated_program()
self.assertEqual(program.scope_counts['nonreporting_count'], 0)
self.assertEqual(program.scope_counts['indicator_count'], 2)
def setUp(self):
country = w_factories.CountryFactory()
self.program_empty = w_factories.RFProgramFactory()
self.program_empty.country.add(country)
self.program_full = w_factories.RFProgramFactory(tiers=True, levels=1)
self.program_full.country.add(country)
for level in self.program_full.levels.all():
indicator = i_factories.RFIndicatorFactory(program=self.program_full, level=level, targets=True)
site = w_factories.SiteProfileFactory(country=country)
result = i_factories.ResultFactory(indicator=indicator, achieved=100)
result.site.set([site])
self.site = site
tola_user = w_factories.TolaUserFactory(country=country)
w_factories.grant_program_access(tola_user, self.program_empty, country, 'high')
self.client.force_login(tola_user.user)
def add_result(self, value, target=None, indicator=None):
indicator = self.indicator if indicator is None else indicator
if target is None:
target = self.targets[indicator.pk][self.result_target[
indicator.pk]]
self.result_target[
indicator.pk] = (self.result_target[indicator.pk] + 1) % len(
self.targets[indicator.pk])
date_collected = target.start_date + datetime.timedelta(
days=len(self.data[indicator.pk][target.customsort]))
data = i_factories.ResultFactory(indicator=indicator,
achieved=value,
periodic_target=target,
date_collected=date_collected)
self.data[indicator.pk][target.customsort].append(data)
return data
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 add_result(self, indicator):
return i_factories.ResultFactory(
indicator=indicator,
program=self.program,
achieved=100,
date_collected=self.program.reporting_period_start)
def add_result(self, indicator):
return i_factories.ResultFactory(indicator=indicator, achieved=100)
def test_midend_target_sums_midend_with_both_data(self):
self.indicator.target_frequency = Indicator.MID_END
self.indicator.save()
mid_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=500,
period=PeriodicTarget.MIDLINE,
customsort=0
)
end_target = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=800,
period=PeriodicTarget.ENDLINE,
customsort=1
)
self.targets.extend([mid_target, end_target])
mid_data = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=mid_target,
achieved=350,
date_collected=self.program.reporting_period_start + datetime.timedelta(days=1)
)
end_data = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=end_target,
achieved=950,
date_collected=self.program.reporting_period_start + datetime.timedelta(days=10)
)
self.data.extend([mid_data, end_data])
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
# both have data, defaults to non_cumulative, so should show sum of both targets:
self.assertEqual(
indicator.lop_target_progress, 1300,
"should sum both targets 500 and 800 to get 1300, got {0}".format(indicator.lop_target_progress)
)
# both have data and targets, defaults to non_cumulative, should show sum of both data:
self.assertEqual(
indicator.lop_actual_progress, 1300,
"should sum both data 350 and 950 to get 1300, got {0}".format(indicator.lop_actual_progress)
)
self.assertEqual(
indicator.over_under, 0,
"should show overunder as 0 (in range), got {0}".format(indicator.over_under)
)
self.indicator.is_cumulative = True
self.indicator.save()
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
# both have data, set to cumulative, so should show latest (endline) target:
self.assertEqual(
indicator.lop_target_progress, 800,
"should show latest target (800), got {0}".format(indicator.lop_target_progress)
)
# both have data and targets, defaults to non_cumulative, should show sum of both data:
self.assertEqual(
indicator.lop_actual_progress, 1300,
"should show all data (1300), got {0}".format(indicator.lop_actual_progress)
)
self.assertEqual(
indicator.over_under, 1,
"should show overunder as 1 (over range), got {0}".format(indicator.over_under)
)
self.indicator.direction_of_change = Indicator.DIRECTION_OF_CHANGE_NEGATIVE
self.indicator.save()
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
self.assertEqual(
indicator.over_under, -1,
"should show overunder as -1 (under range - negative DOC), got {0}".format(indicator.over_under)
)
def test_event_sums_all_targets_using_customsort(self):
self.indicator.target_frequency = Indicator.EVENT
self.indicator.save()
target_1 = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=500,
period="event 1",
customsort=0
)
target_2 = i_factories.PeriodicTargetFactory(
indicator=self.indicator,
target=800,
period="event 2",
customsort=1
)
self.targets.extend([target_1, target_2])
data_1 = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=target_1,
achieved=350,
date_collected=self.program.reporting_period_start + datetime.timedelta(days=1)
)
self.data.append(data_1)
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
# both have data, defaults to non_cumulative, so should show sum of both targets:
self.assertEqual(
indicator.lop_target_progress, 500,
"should not sum targets (no data for second target) expecting 500, got {0}".format(
indicator.lop_target_progress)
)
self.assertEqual(
indicator.lop_actual_progress, 350,
"should show only data, 350 got {0}".format(indicator.lop_actual_progress)
)
self.assertEqual(
indicator.over_under, -1,
"should show under (350/500), got {0}".format(indicator.over_under)
)
data_2 = i_factories.ResultFactory(
indicator=self.indicator,
periodic_target=target_2,
achieved=950,
date_collected=self.program.reporting_period_start + datetime.timedelta(days=20)
)
self.data.append(data_2)
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
self.assertEqual(
indicator.lop_target_progress, 1300,
"expected sum of targets (both have data) 1300, got {0}".format(indicator.lop_target_progress)
)
self.assertEqual(
indicator.lop_actual_progress, 1300,
"expecting sum of data 1300, got {0}".format(indicator.lop_actual_progress)
)
self.assertEqual(
indicator.over_under, 0,
"should show on target (over under 0, 1300/1300), got {0}".format(indicator.over_under)
)
self.indicator.is_cumulative = True
self.indicator.save()
indicator = MetricsIndicator.objects.with_annotations('scope').get(pk=self.indicator.id)
self.assertEqual(
indicator.lop_target_progress, 800,
"expected most recent target for non-cumulative indicator 800, got {0}".format(
indicator.lop_target_progress)
)
