class TestIndicatorGetCurrentPeriodicTarget(TestBase, TestCase):
"""
Test getting the current PeriodicTarget of an Indicator based on a contained date
"""
def setUp(self):
super(TestIndicatorGetCurrentPeriodicTarget, self).setUp()
self.indicator = IndicatorFactory(
program=self.program,
unit_of_measure_type=Indicator.NUMBER,
is_cumulative=False,
direction_of_change=Indicator.DIRECTION_OF_CHANGE_NONE,
target_frequency=Indicator.MONTHLY)
def test_current_periodic_target_accessor_monthly(self):
_create_3_periodic_targets(self.indicator)
# test in range
self.assertEquals(
self.indicator.current_periodic_target(datetime.date(2016, 4,
15)).target,
20)
# test out of range
self.assertIsNone(
self.indicator.current_periodic_target(datetime.date(2017, 4, 15)))
# test no date given
self.assertIsNone(self.indicator.current_periodic_target())
def test_current_periodic_target_accessor_none(self):
self.assertIsNone(
self.indicator.current_periodic_target(datetime.date(2016, 4, 15)))
def setUp(self):
super(TestIndicatorGetCurrentPeriodicTarget, self).setUp()
self.indicator = IndicatorFactory(
program=self.program,
unit_of_measure_type=Indicator.NUMBER,
is_cumulative=False,
direction_of_change=Indicator.DIRECTION_OF_CHANGE_NONE,
target_frequency=Indicator.MONTHLY)
def test_indicator_manual_sorting_manual_display_unmigrated(self):
program = RFProgramFactory(migrated=False)
indicator = Indicator.rf_aware_objects.get(pk=IndicatorFactory(
program=program).pk)
self.assertEqual(indicator.manual_number_display, True)
for number, a in self.numbers:
indicator = Indicator.rf_aware_objects.get(
pk=IndicatorFactory(program=program, number=number).pk)
self.assertEqual(indicator.sort_number[0], a)
def test_out_of_program_indicators_ignored(self):
other_program = ProgramFactory()
other_indicator1 = IndicatorFactory(
target_frequency=self.indicator_frequency, program=other_program)
other_indicator2 = IndicatorFactory(
target_frequency=self.indicator_frequency, program=other_program)
_ = self.get_indicator_by_frequency(self.indicator_frequency)
response = self.get_response(self.indicator_frequency)
self.assertEqual(
len(response.indicators), 1,
self.format_assert_message(
"One LOP indicator added, two on other program,, expected 1 in return, got {0}"
.format(len(response.indicators))))
def test_get_sites(self):
"""It should return all and only the sites for a given program"""
expected = SiteProfileFactory()
expected2 = SiteProfileFactory()
ResultFactory(indicator=self.indicator, sites=[expected, expected2])
sites = self.program.get_sites()
IndicatorFactory.create_batch(3)
ResultFactory.create_batch(3)
SiteProfileFactory.create_batch(3)
self.assertEqual(len(sites), 2)
self.assertEqual(len(SiteProfile.objects.all()), 5)
def test_one_indicator_of_each_frequency(self):
indicator = IndicatorFactory(program=self.program)
for frequency, name in Indicator.TARGET_FREQUENCIES:
if frequency != Indicator.EVENT:
indicator.target_frequency = frequency
indicator.save()
response = self.client.get(self.url).json()
expected = [{
'frequency_name': name,
'target_frequency': frequency
}]
self.assertEqual(
response, expected,
"One {0} indicator expected {1} but got {2}".format(
name, expected, response))
def test_out_of_program_indicators_ignored(self):
other_program = ProgramFactory()
# add other indicators (out of program):
IndicatorFactory(target_frequency=self.indicator_frequency,
program=other_program)
IndicatorFactory(target_frequency=self.indicator_frequency,
program=other_program)
self.get_indicator_by_frequency(self.indicator_frequency)
response = self.get_response(self.indicator_frequency)
self.assertEqual(
len(response['indicators']), 1,
self.format_assert_message(
"One {freq} indicator added + 2 in alt program,,expected 1 in return, got {num}"
.format(freq=self.indicator_frequency,
num=len(response['indicators']))))
def setUp(self):
self.user = UserFactory(first_name="Indicator",
last_name="CreateTest",
username="******")
self.user.set_password('password')
self.user.save()
self.tola_user = TolaUserFactory(user=self.user)
self.country = self.tola_user.country
self.program = ProgramFactory(funding_status='Funded',
reporting_period_start='2016-03-01',
reporting_period_end='2020-05-01')
self.program.country.add(self.country)
self.program.save()
self.indicator = IndicatorFactory(
program=self.program,
unit_of_measure_type=Indicator.NUMBER,
is_cumulative=False,
direction_of_change=Indicator.DIRECTION_OF_CHANGE_NONE,
target_frequency=Indicator.ANNUAL)
self.request_factory = RequestFactory()
self.client = Client()
self.client.login(username="******", password='******')
def generate_core_indicator_data(c_params=None, p_count=3, i_count=4):
"""
Create up to 5 countries and an arbitrary number of related programs and indicators
"""
if c_params is None:
c_params = [
('Colombia', 'CO'),
('Tunisia', 'TN'),
]
program_ids = []
indicator_ids = []
for i in range(len(c_params)):
country = CountryFactory(country=c_params[i][0], code=c_params[i][1])
programs = ProgramFactory.create_batch(
p_count,
countries=[country],
name=Sequence(lambda n: 'Program %s %s' % (country.code, n)),
funding_status="Funded",
)
for p in programs:
program_ids.append(p.id)
indicators = IndicatorFactory.create_batch(
i_count,
program=p,
unit_of_measure_type=Indicator.NUMBER,
is_cumulative=False,
direction_of_change=Indicator.DIRECTION_OF_CHANGE_NONE,
target_frequency=Indicator.ANNUAL)
indicator_ids = [i.id for i in indicators]
p.indicator_set.add(*indicators)
return program_ids, indicator_ids
def indicator_for_scenario(self, scenario):
indicator = IndicatorFactory(
target_frequency=Indicator.TRI_ANNUAL,
is_cumulative=scenario['cumulative'],
direction_of_change=(Indicator.DIRECTION_OF_CHANGE_POSITIVE
if scenario['positive'] else
Indicator.DIRECTION_OF_CHANGE_NEGATIVE),
unit_of_measure_type=(Indicator.NUMBER if scenario['number'] else
Indicator.PERCENTAGE),
program=self.program)
for target_number, period in zip(scenario['targets'],
dates['targets']):
self.targets.append(
PeriodicTargetFactory(indicator=indicator,
target=target_number,
start_date=get_date(period[0]),
end_date=get_date(period[1])))
for c, data_set in enumerate(scenario['data']):
date_set = dates['collects'][c]
for data, date in zip(data_set, date_set):
self.data.append(
CollectedDataFactory(periodic_target=self.targets[c],
achieved=data,
indicator=indicator,
program=self.program,
date_collected=get_date(date)))
return indicator
def instantiate_scenario(program_id, scenario, existing_indicator_ids=None):
if existing_indicator_ids and len(
scenario.indicators) != len(existing_indicator_ids):
raise ImproperlyConfigured(
"Can't instatiate scenario, indicator count (%s) doesn't match scenario indicator count (%s)"
% (len(existing_indicator_ids), len(scenario.indicators)))
indicator_ids = []
program = Program.objects.get(id=program_id)
for n, indicator_value_set in enumerate(scenario.indicators):
if existing_indicator_ids:
indicator = Indicator.objects.get(id=existing_indicator_ids[n])
else:
indicator = IndicatorFactory(
program=program,
is_cumulative=indicator_value_set.is_cumulative,
unit_of_measure_type=indicator_value_set.unit_of_measure_type,
direction_of_change=indicator_value_set.direction_of_change,
target_frequency=indicator_value_set.target_frequency,
lop_target=indicator_value_set.lop_target,
)
# It's important to return indicator_ids in order. Preserving the creation order also preserves
# the link between the scenario and the indicator that was created in the database.
indicator_ids.append(indicator.id)
make_targets(program, indicator)
periodic_targets = PeriodicTarget.objects.filter(
indicator__id=indicator.id)
if len(periodic_targets) != len(indicator_value_set.periodic_targets):
raise ImproperlyConfigured(
"Scenario's periodic target count (%s) doesn't match program-based periodic target count (%s)."
% (len(indicator_value_set.periodic_targets),
len(periodic_targets)))
for i, pt in enumerate(periodic_targets):
pt.target = indicator_value_set.periodic_targets[i].target
pt.save()
try:
evidence_values = indicator_value_set.periodic_targets[
i].evidence
except KeyError:
evidence_values = []
for j, res_value in enumerate(
indicator_value_set.periodic_targets[i].results):
dc = pt.start_date
if dc is None:
dc = pt.indicator.program.reporting_period_start
dc = dc + datetime.timedelta(days=j)
res = ResultFactory(periodic_target=pt,
indicator=indicator,
program=program,
achieved=res_value,
date_collected=dc)
if evidence_values and evidence_values[j]:
res.evidence_url = 'http://www.example.com'
res.record_name = 'evidence name'
res.save()
return indicator_ids
class TestIndicatorInstance(test.TestCase):
def setUp(self):
self.level = LevelFactory()
self.indicator = IndicatorFactory(name="testname", level=self.level)
def tearDown(self):
self.level.delete()
self.indicator.delete()
def test_instances(self):
indicators = IPTTIndicator.notargets.all()
self.assertEqual(len(indicators), 1)
self.assertEqual(indicators[0].name, self.indicator.name)
def test_level(self):
indicator = IPTTIndicator.notargets.first()
self.assertEqual(indicator.level_name, self.level.name)
def test_satsuma_program(self):
program = Program.rf_aware_objects.get(pk=RFProgramFactory(
migrated=None).pk)
self.assertEqual(program.using_results_framework, True)
indicator = Indicator.rf_aware_objects.get(pk=IndicatorFactory(
program=program).pk)
self.assertEqual(indicator.using_results_framework, True)
program_indicator = program.rf_aware_indicators.first()
self.assertEqual(program_indicator.using_results_framework, True)
def instantiate_scenario(program_id, scenario, existing_indicator_ids=None):
if existing_indicator_ids and len(
scenario.indicators) != len(existing_indicator_ids):
raise ImproperlyConfigured(
"Can't instatiate scenario, indicator count (%s) doesn't match scenario indicator count (%s)"
% (len(existing_indicator_ids), len(scenario.indicators)))
indicator_ids = []
program = Program.objects.get(id=program_id)
for n, indicator_value_set in enumerate(scenario.indicators):
if existing_indicator_ids:
indicator = Indicator.objects.get(id=existing_indicator_ids[n])
else:
indicator = IndicatorFactory(
program=program,
is_cumulative=indicator_value_set.is_cumulative,
direction_of_change=indicator_value_set.direction_of_change,
target_frequency=indicator_value_set.target_frequency,
lop_target=indicator_value_set.lop_target,
)
# It's important to return indicator_ids in order. Preserving the creation order also preserves
# the link between the scenario and the indicator that was created in the database.
indicator_ids.append(indicator.id)
make_targets(program, indicator)
periodic_targets = PeriodicTarget.objects.filter(
indicator__id=indicator.id)
if len(periodic_targets) != len(indicator_value_set.periodic_targets):
raise ImproperlyConfigured(
"Scenario's periodic target count (%s) doesn't match program-based periodic target count (%s)."
% (len(indicator_value_set.periodic_targets),
len(periodic_targets)))
for i, pt in enumerate(periodic_targets):
pt.target = indicator_value_set.periodic_targets[i].target
pt.save()
try:
evidence_values = indicator_value_set.periodic_targets[
i].evidence
except KeyError:
evidence_values = []
for j, cd_value in enumerate(
indicator_value_set.periodic_targets[i].collected_data):
cd = CollectedDataFactory(
periodic_target=pt,
indicator=indicator,
program=program,
achieved=cd_value,
)
if evidence_values and evidence_values[j]:
cd.evidence = DocumentationFactory()
cd.save()
return indicator_ids
def test_sorting_by_numbers_unmigrated(self):
program = Program.rf_aware_objects.get(pk=RFProgramFactory(
migrated=False).pk)
these_numbers = self.numbers[0]
to_assign = these_numbers[0:]
to_assign.reverse()
for number in to_assign:
IndicatorFactory(program=program, number=number)
indicators = unassigned_sort_func(
Indicator.rf_aware_objects.filter(program=program))
self.assertEqual([i.number for i in indicators], these_numbers)
def test_multiple_indicators(self):
for frequency in [
Indicator.LOP, Indicator.LOP, Indicator.MID_END,
Indicator.SEMI_ANNUAL
]:
IndicatorFactory(program=self.program, target_frequency=frequency)
response = self.client.get(self.url).json()
self.assertEqual(len(response), 3)
self.assertEqual(
set([x['target_frequency'] for x in response]),
set([Indicator.LOP, Indicator.MID_END, Indicator.SEMI_ANNUAL]))
def test_sorting_by_level_order_migrated(self):
program = Program.objects.get(pk=RFProgramFactory(migrated=True).pk)
level = LevelFactory(program=program)
these_numbers = self.numbers[0]
to_assign = these_numbers[0:]
to_assign.reverse()
for count, number in enumerate(to_assign):
IndicatorFactory(program=program,
number=number,
level=level,
level_order=count)
indicators = unassigned_sort_func(
Indicator.rf_aware_objects.filter(program=program))
self.assertEqual([i.number for i in indicators], to_assign)
def test_soft_deleted_indicators_hidden(self):
program = RFProgramFactory()
IndicatorFactory(program=program)
IndicatorFactory(program=program)
deleted_indicator = IndicatorFactory(program=program)
deleted_indicator.delete()
self.assertEqual(len(program.indicator_set.all()), 2)
self.assertEqual(
len(Indicator.rf_aware_objects.filter(program=program)), 2)
def get_indicator_for_program(self, **kwargs):
make_kwargs = {'program': self.program}
make_kwargs.update(kwargs)
indicator = IndicatorFactory(**make_kwargs)
return indicator
def add_indicator(self, targets=None, values=None):
indicator = IndicatorFactory(target_frequency=self.indicator_frequency,
program=self.program)
self.indicators.append(indicator)
self.add_periodic_targets(indicator, targets=targets, values=values)
def setUp(self):
self.level = LevelFactory()
self.indicator = IndicatorFactory(name="testname", level=self.level)
def test_indicator_manual_sorting_manual_display_migrated(self):
program = RFProgramFactory(migrated=True)
indicator = Indicator.rf_aware_objects.get(pk=IndicatorFactory(
program=program).pk)
self.assertEqual(indicator.manual_number_display, False)
def test_indicator_manual_sorting_manual_display_rf_always_auto_off(self):
program = RFProgramFactory(migrated=None, auto_number_indicators=False)
indicator = Indicator.rf_aware_objects.get(pk=IndicatorFactory(
program=program).pk)
self.assertEqual(indicator.manual_number_display, True)
