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)