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)