def test_is_cumulative(self):
data = self.get_indicator_data(program=RFProgramFactory(), is_cumulative=False)
self.assertEqual(data['is_cumulative'], False)
data2 = self.get_indicator_data(program=RFProgramFactory(), is_cumulative=True)
self.assertEqual(data2['is_cumulative'], True)
data3 = self.get_indicator_data(program=RFProgramFactory(), is_cumulative=None)
self.assertEqual(data3['is_cumulative'], None)
def test_needs_additional_target_periods_no_reporting_period_end(self):
p = RFProgramFactory()
RFIndicatorFactory(program=p, target_frequency=Indicator.TRI_ANNUAL, targets=1000)
p.reporting_period_end = None
p.save()
data = ProgramPageProgramSerializer(
Program.program_page_objects.filter(pk=p.pk), many=True
).data[0]
self.assertFalse(data['needs_additional_target_periods'])
def test_frequencies(self):
p1 = RFProgramFactory()
RFIndicatorFactory(program=p1, target_frequency=Indicator.LOP, targets=200)
p2 = RFProgramFactory()
RFIndicatorFactory(program=p2, target_frequency=Indicator.ANNUAL, targets=1000)
data = self.get_serialized_data([p1.pk, p2.pk])
self.assertEqual(len(data), 2)
data1 = [d for d in data if d['pk'] == p1.pk][0]
self.assertEqual(data1['frequencies'], [1])
data2 = [d for d in data if d['pk'] == p2.pk][0]
self.assertEqual(data2['frequencies'], [3])
def test_multiple_programs(self):
p = RFProgramFactory(migrated=False)
RFIndicatorFactory(program=p, target_frequency=Indicator.LOP, targets=500)
RFIndicatorFactory(program=p, target_frequency=Indicator.ANNUAL, targets=200)
p2 = RFProgramFactory(migrated=True, tiers=True, levels=1)
RFIndicatorFactory(program=p2, target_frequency=Indicator.SEMI_ANNUAL, targets=5000)
RFIndicatorFactory(program=p2, target_frequency=Indicator.ANNUAL, targets=200)
p3 = RFProgramFactory(tiers=['Tier1', 'Tier2'], levels=2)
for level in p3.levels.all():
RFIndicatorFactory(program=p3, target_frequency=Indicator.MONTHLY, targets=5000, level=level)
with self.assertNumQueries(2):
data = {d['pk']: d for d in self.get_serialized_data(p.pk, p2.pk, p3.pk)}
self.assertEqual(data[p.pk]['frequencies'], [1, 3])
self.assertEqual(data[p2.pk]['frequencies'], [3, 4])
self.assertEqual(data[p3.pk]['frequencies'], [7])
def test_rf_program_two_indicators_update_only(self):
p = RFProgramFactory(
tiers=['Tier1', 'Tier2'], levels=1,
)
expected_pks = []
levels = sorted(p.levels.all(), key=operator.attrgetter('level_depth'))
for level in levels:
expected_pks.append(RFIndicatorFactory(program=p, level=level).pk)
indicator = RFIndicatorFactory(program=p, level=levels[1], name='Test Name')
expected_pks.append(indicator.pk)
full_data = ProgramPageProgramSerializer.get_for_pk(p.pk).data
with self.assertNumQueries(5):
data = ProgramPageUpdateSerializer.update_indicator_pk(p.pk, indicator.pk).data
self.assertEqual(len(data), 5)
self.assertEqual(data['pk'], p.pk)
self.assertEqual(data['indicator_pks_level_order'], data['indicator_pks_chain_order'])
indicator_pks = data['indicator_pks_level_order']
self.assertEqual(indicator_pks, expected_pks)
self.assertEqual(data['indicator']['name'], 'Test Name')
for indicator_pk in full_data['indicators']:
self.assertIn(indicator_pk, data['indicators'])
self.assertEqual(
full_data['indicators'][indicator_pk]['number'],
data['indicators'][indicator_pk]['number']
)
def test_rf_program_two_indicators(self):
p = RFProgramFactory(
tiers=['Tier1', 'Tier2'], levels=1,
reporting_period_start=datetime.date(2014, 5, 1)
)
for level in p.levels.all():
RFIndicatorFactory(program=p, level=level)
with self.assertNumQueries(4):
data = ProgramPageProgramSerializer.get_for_pk(p.pk).data
self.assertEqual(data['pk'], p.pk)
self.assertEqual(data['name'], p.name)
self.assertTrue(data['results_framework'])
self.assertEqual(data['by_result_chain'], 'by Tier2 chain')
self.assertEqual(data['reporting_period_start_iso'], '2014-05-01')
self.assertEqual(data['site_count'], 0)
self.assertTrue(data['has_levels'])
self.assertEqual(data['indicator_pks_level_order'], data['indicator_pks_chain_order'])
indicator_pks = data['indicator_pks_level_order']
self.assertEqual(len(indicator_pks), 2)
indicators_data = data['indicators']
self.assertEqual(len(indicators_data), 2)
goal_indicator_data = indicators_data[indicator_pks[0]]
self.assertEqual(goal_indicator_data['number'], 'Tier1 a')
output_indicator_data = indicators_data[indicator_pks[1]]
self.assertEqual(output_indicator_data['number'], 'Tier2 1a')
def test_manual_numbering(self):
p = RFProgramFactory(tiers=['Tier1', 'Tier2', 'Tier3'], levels=1, auto_number_indicators=False)
levels = list(
sorted(
sorted(
[l for l in p.levels.all()],
key=lambda l: l.customsort
), key=lambda l: l.level_depth
)
)
numbers = ['482', '28.C', '999']
pks = []
for level, number in zip(list(reversed(levels)), numbers):
pks.append(
RFIndicatorFactory(
program=p,
level=level,
number=number
).pk
)
expected_pks = list(reversed(pks))
expected_numbers = list(reversed(numbers))
with self.assertNumQueries(4):
data = ProgramPageProgramSerializer.get_for_pk(p.pk).data
self.assertEqual(len(data['indicators']), 3)
self.assertEqual(data['indicator_pks_level_order'], expected_pks)
self.assertEqual(data['indicator_pks_chain_order'], expected_pks)
for pk, number in zip(expected_pks, expected_numbers):
self.assertEqual(data['indicators'][pk]['number'], number)
def test_program_mercycorps_tiers(self):
program = RFProgramFactory(tiers=True)
goal = LevelFactory(program=program, parent=None)
output1 = LevelFactory(program=program, parent=goal)
output2 = LevelFactory(program=program, parent=goal)
impact11 = LevelFactory(program=program, parent=output1)
impact12 = LevelFactory(program=program, parent=output1)
impact21 = LevelFactory(program=program, parent=output2)
data = get_serialized_data(program.pk)
self.assertEqual(data['level_pks_level_order'], [
goal.pk, output1.pk, output2.pk, impact11.pk, impact12.pk,
impact21.pk
])
self.assertEqual(data['level_pks_chain_order'], [
goal.pk, output1.pk, impact11.pk, impact12.pk, output2.pk,
impact21.pk
])
self.assertEqual(
sorted(data['indicator_pks_for_level'], key=lambda l: l['pk']),
sorted([{
'pk': level_pk,
'indicator_pks': []
} for level_pk in [
goal.pk, output1.pk, impact11.pk, impact12.pk, output2.pk,
impact21.pk
]],
key=lambda l: l['pk']))
self.assertEqual(data['unassigned_indicator_pks'], [])
def test_one_program(self):
p = RFProgramFactory()
RFIndicatorFactory(program=p, target_frequency=Indicator.LOP, targets=500)
RFIndicatorFactory(program=p, target_frequency=Indicator.ANNUAL, targets=200)
with self.assertNumQueries(2):
data = self.get_serialized_data(p.pk)[0]
self.assertEqual(data['frequencies'], [1, 3])
def test_old_level_in_rf_no_level_id(self):
p = RFProgramFactory(tiers=["Tier1", "Tier2"],
levels=1,
levels__1={'id': 901})
data = self.get_indicator_data(program=p, old_level="Output")
self.assertEqual(data['level_pk'], None)
self.assertEqual(data['old_level_name'], None)
def test_non_rf_level_with_level_assigned(self):
p = RFProgramFactory(migrated=False)
data = self.get_indicator_data(program=p,
level=LevelFactory(program=p, pk=5),
old_level="Outcome")
self.assertEqual(data['old_level_name'], "Outcome")
self.assertEqual(data['level_pk'], 3)
def test_good_level_pk(self):
p = RFProgramFactory(tiers=["Tier1", "Tier2"],
levels=1,
levels__1={'id': 901})
data = self.get_indicator_data(program=p,
level=p.levels.filter(pk=901).first())
self.assertEqual(data['level_pk'], 901)
def test_reporting_open_program_lop_with_results(self):
data = self.get_indicator_data(program=RFProgramFactory(closed=False),
target_frequency=Indicator.LOP,
targets=True,
results=True)
self.assertEqual(data['is_reporting'], False)
self.assertEqual(data['over_under'], None)
def test_program_unmigrated_indicators_old_level_new_level_and_number_order(self):
translation.activate('fr')
p = RFProgramFactory(migrated=False)
l1 = LevelFactory(program=p, parent=None, customsort=0)
l2 = LevelFactory(program=p, parent=l1, customsort=0)
indicators = [
RFIndicatorFactory(program=p, old_level=old_level, number=number, level=level)
for old_level, number, level in reversed([
('Goal', '2', None), ('Outcome', '1', None), ('Outcome', '1.2', l1), ('Outcome', '1.3', None),
('Output', '1.1.1', l2), ('Output', '1.1.2', None), ('Activity', '1.1.2.1', l1)
])
]
indicator_pks = [i.pk for i in indicators]
data = ProgramLevelOrderingProgramSerializer(
Program.rf_aware_objects.filter(pk=p.pk), many=True
).data[0]
self.assertEqual(
data['indicator_pks_level_order'],
list(reversed(indicator_pks))
)
self.assertEqual(
data['indicator_pks_chain_order'],
list(reversed(indicator_pks))
)
translation.activate('en')
def test_unmigrated_program(self):
p = RFProgramFactory(migrated=False)
pks = []
old_levels_numbers = [('Activity', '5'), ('Activity', '3'),
('Outcome', '3.4'), ('Outcome', '2.8'),
('Outcome', '2.2')]
for old_level, number in old_levels_numbers:
pks.append(
RFIndicatorFactory(program=p,
old_level=old_level,
number=number,
target_frequency=Indicator.SEMI_ANNUAL,
targets=400,
results=550).pk)
expected_pks = list(reversed(pks))
with self.assertNumQueries(IPTT_QUERY_COUNT):
data = get_serialized_data(p.pk)
self.assertEqual(expected_pks, data['unassigned_indicator_pks'])
self.assertEqual(data['level_pks_level_order'], [])
self.assertEqual(data['level_pks_chain_order'], [])
self.assertEqual(data['indicator_pks_for_level'], [])
self.assertEqual(data['frequencies'], [Indicator.SEMI_ANNUAL])
activity = [
i_data for i_data in data['indicators'] if i_data['number'] == '5'
][0]
self.assertEqual(activity['old_level_name'], 'Activity')
translation.activate('fr')
with self.assertNumQueries(IPTT_QUERY_COUNT):
french_data = get_serialized_data(p.pk)
activity = [
i_data for i_data in french_data['indicators']
if i_data['number'] == '5'
][0]
self.assertEqual(activity['old_level_name'], u'Activité')
translation.activate('en')
def test_program_migrated_one_indicator_per_level(self):
p = RFProgramFactory(tiers=["Tier1", "Tier2", "Tier3"])
l1 = LevelFactory(program=p, parent=None, customsort=0)
l11 = LevelFactory(program=p, parent=l1, customsort=0)
l111 = LevelFactory(program=p, parent=l11, customsort=0)
l112 = LevelFactory(program=p, parent=l11, customsort=1)
l12 = LevelFactory(program=p, parent=l1, customsort=1)
l121 = LevelFactory(program=p, parent=l12, customsort=0)
l122 = LevelFactory(program=p, parent=l12, customsort=1)
i1 = RFIndicatorFactory(program=p, level=l1, level_order=0)
i11 = RFIndicatorFactory(program=p, level=l11, level_order=0)
i111 = RFIndicatorFactory(program=p, level=l111, level_order=0)
i112 = RFIndicatorFactory(program=p, level=l112, level_order=0)
i12 = RFIndicatorFactory(program=p, level=l12, level_order=0)
i121 = RFIndicatorFactory(program=p, level=l121, level_order=0)
i122 = RFIndicatorFactory(program=p, level=l122, level_order=0)
data = ProgramLevelOrderingProgramSerializer(
Program.rf_aware_objects.filter(pk=p.pk), many=True
).data[0]
self.assertEqual(
data['indicator_pks_level_order'],
[i1.pk, i11.pk, i12.pk, i111.pk, i112.pk, i121.pk, i122.pk]
)
self.assertEqual(
data['indicator_pks_chain_order'],
[i1.pk, i11.pk, i111.pk, i112.pk, i12.pk, i121.pk, i122.pk]
)
def test_needs_additional_target_periods_no_targets(self):
p = RFProgramFactory()
RFIndicatorFactory(program=p)
data = ProgramPageProgramSerializer(
Program.program_page_objects.filter(pk=p.pk), many=True
).data[0]
self.assertFalse(data['needs_additional_target_periods'])
def test_one_duplicated_sector(self):
program = RFProgramFactory()
sector = SectorFactory(program=program)
RFIndicatorFactory(program=program, sector=sector)
RFIndicatorFactory(program=program, sector=sector)
data = get_serialized_data(program.pk)
self.assertEqual(len(data['sectors']), 1)
def test_translated_tiers(self):
program = RFProgramFactory(tiers=True)
translation.activate('fr')
data = get_serialized_data(program.pk)
names = set(td['name'] for td in data['tiers'])
self.assertIn(u'Résultat', names)
translation.activate('en')
def test_migrated_has_translated_level_number(self):
p = RFProgramFactory(tiers=['tier1', 'Outcome'], levels=True)
l = [l for l in p.levels.all() if l.level_depth == 2][0]
translation.activate('fr')
data = self.get_indicator_data(program=p, level=l, level_order=0)
translation.activate('en')
self.assertEqual(data['number'], u"Résultat 1a")
def test_results_count_zero(self):
data = self.get_indicator_data(program=RFProgramFactory(),
target_frequency=Indicator.SEMI_ANNUAL,
targets=1000)
self.assertEqual(data['results_count'], 0)
self.assertEqual(data['has_results'], False)
self.assertEqual(data['missing_evidence'], False)
def test_period_date_ranges(self):
p = RFProgramFactory(closed=False, months=12, age=4) # 4+months ago
RFIndicatorFactory(program=p, target_frequency=Indicator.LOP, targets=200)
data = self.get_serialized_data([p.pk])[0]
self.assertEqual(data['pk'], p.pk)
for frequency, count in [(1, 1), (2, 2), (3, 1), (4, 2), (5, 3), (6, 4), (7, 12)]:
self.assertEqual(len(data['period_date_ranges'][frequency]), count)
self.assertEqual(len([f for f in data['period_date_ranges'][7] if f['past']]), 5)
def test_needs_additional_target_periods_true(self):
p = RFProgramFactory()
i = RFIndicatorFactory(program=p, target_frequency=Indicator.TRI_ANNUAL, targets=500)
i.periodictargets.last().delete()
data = ProgramPageProgramSerializer(
Program.program_page_objects.filter(pk=p.pk), many=True
).data[0]
self.assertTrue(data['needs_additional_target_periods'])
def test_one_sector(self):
program = RFProgramFactory()
sector = SectorFactory(program=program)
RFIndicatorFactory(program=program, sector=sector)
data = get_serialized_data(program.pk)
self.assertEqual(len(data['sectors']), 1)
self.assertEqual(data['sectors'][0]['pk'], sector.pk)
self.assertEqual(data['sectors'][0]['name'], sector.sector)
def test_migrated_has_level_number_lower_tier(self):
p = RFProgramFactory(tiers=['tier1', 'tier2', 'tier3'], levels=2)
l1 = [l for l in p.levels.all() if l.level_depth == 2][0]
level = p.levels.filter(parent=l1, customsort=2).first()
RFIndicatorFactory(program=p, level=level, level_order=0)
RFIndicatorFactory(program=p, level=level, level_order=1)
data = self.get_indicator_data(program=p, level=level, level_order=2)
self.assertEqual(data['number'], "tier3 1.2c")
def test_has_one_site_pk(self):
i = RFIndicatorFactory(
program=RFProgramFactory(), target_frequency=Indicator.LOP,
targets=1000, results=True)
site = SiteProfileFactory()
i.result_set.first().site.add(site)
data = get_serialized_data(i.pk)
self.assertEqual(data['site_pks'], [site.pk])
def test_results_count(self):
data = self.get_indicator_data(program=RFProgramFactory(),
target_frequency=Indicator.SEMI_ANNUAL,
targets=1000,
results=1000,
results__count=2)
self.assertEqual(data['results_count'], 2)
self.assertEqual(data['has_results'], True)
def test_results_count_lop(self):
data = self.get_indicator_data(program=RFProgramFactory(),
target_frequency=Indicator.LOP,
targets=1000,
results=1000,
results__count=10)
self.assertEqual(data['results_count'], 10)
self.assertEqual(data['has_results'], True)
def test_has_two_type_pks(self):
it1 = IndicatorTypeFactory()
it2 = IndicatorTypeFactory()
i = RFIndicatorFactory(program=RFProgramFactory())
i.indicator_type.add(it1)
i.indicator_type.add(it2)
data = get_serialized_data(i.pk)
self.assertEqual(data['indicator_type_pks'], sorted([it1.pk, it2.pk]))
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)
