def test_active_country_gets_program(self): active_country = w_factories.CountryFactory( country="Active", code="AT", ) inactive_country = w_factories.CountryFactory(country="Inactive", code="IT") country_access_active = w_factories.CountryAccessFactory( country=active_country, tolauser=self.tola_user) country_access_inactive = w_factories.CountryAccessFactory( country=inactive_country, tolauser=self.tola_user) self.tola_user.countryaccess_set.add(country_access_active, country_access_inactive) self.tola_user.active_country = active_country self.tola_user.save() active_program = w_factories.ProgramFactory(funding_status="Funded", ) active_program.country.set([active_country]) inactive_program = w_factories.ProgramFactory(funding_status="Funded") inactive_program.country.clear() inactive_program.country.set([inactive_country]) response = self.client.get('/') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.context['programs']), 1) self.assertEqual(response.context['programs'][0].id, active_program.id) # test selected country overrides: response = self.client.get('/{pk}/'.format(pk=inactive_country.id)) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.context['programs']), 1) self.assertEqual(response.context['programs'][0].id, inactive_program.id) self.tola_user.refresh_from_db() self.assertEqual(self.tola_user.active_country, inactive_country)
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) i_factories.CollectedDataFactory(indicator=indicator, achieved=105) for _ in range(5): indicator = i_factories.IndicatorFactory( target_frequency=Indicator.LOP, lop_target=100, program=program) evidence = w_factories.DocumentationFactory(program=program) i_factories.CollectedDataFactory(indicator=indicator, achieved=50, evidence=evidence) 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 test_program_with_multiple_indicators_returns_correct_date(self): program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2015, 1, 1), reporting_period_end=datetime.date(2015, 12, 31) ) indicator1 = i_factories.IndicatorFactory( target_frequency=Indicator.ANNUAL, program=program ) i_factories.PeriodicTargetFactory( indicator=indicator1, start_date=datetime.date(2015, 1, 1), end_date=datetime.date(2015, 12, 31) ) indicator2 = i_factories.IndicatorFactory( target_frequency=Indicator.TRI_ANNUAL, program=program ) for start, end in [(datetime.date(2015, 1, 1), datetime.date(2015, 4, 30)), (datetime.date(2015, 5, 1), datetime.date(2015, 8, 31)), (datetime.date(2015, 9, 1), datetime.date(2015, 12, 31))]: i_factories.PeriodicTargetFactory( indicator=indicator2, start_date=start, end_date=end ) self.assertEqual(program.last_time_aware_indicator_start_date, datetime.date(2015, 9, 1))
def setUp(self): program = w_factory.ProgramFactory() self.expected = [] for x in reversed(['1', '1.1.1', '2.1.2', '3', '3.2.1.1', '10.1', '1.1a', '1.1b', '1.2a']): self.expected.append(get_indicator(x, program).id) self.expected = reversed(self.expected) self.program_id = program.id
def setUp(self): program = w_factory.ProgramFactory() self.expected = [] for x in reversed(range(10)): self.expected.append(get_indicator(x+1, program).id) self.expected = reversed(self.expected) self.program_id = program.id
def test_reporting_period_bad_both_shows_incorrect(self): program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2015, 1, 15), reporting_period_end=datetime.date(2017, 2, 15) ) homepage_program = ProgramWithMetrics.home_page.with_annotations().get(pk=program.pk) self.assertFalse(homepage_program.reporting_period_correct)
def test_time_aware_indicators_no_completed_periods(self): # if program started yesterday then no targets will be finished by today: today = datetime.date.today() - datetime.timedelta(days=1) self.program = w_factories.ProgramFactory( reporting_period_start=datetime.date(today.year, today.month, 1), reporting_period_end=datetime.date(today.year + 1, today.month, 1) - datetime.timedelta(days=1)) for frequency in [ freq for freq in self.TIME_AWARE_FREQUENCIES if freq != Indicator.MONTHLY ]: # the above hack due to a once-a-month inability to make a period that hasn't finished a month # relative to today. The alternative is monkey-patching mysql's NOW function, which seems bad self.load_base_indicator() self.indicator.target_frequency = frequency self.indicator.save() self.load_targets() self.load_data(date=datetime.date.today() - datetime.timedelta(days=1)) indicator = self.get_annotated_indicator() self.assertFalse(indicator.reporting) for target in self.targets: target.delete() self.targets = [] self.indicator.delete() self.indicator = None
def setUp(self): program = w_factory.ProgramFactory() self.expected = [] for x in reversed(['aasdf', 'basdf', 'casdf', 'daasdf', 'e3214', 'f5235']): self.expected.append(get_indicator(x, program).id) self.expected = reversed(self.expected) self.program_id = program.id
def setUp(self): self.program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2016, 10, 1), reporting_period_end=datetime.date(2017, 9, 30)) self.indicator = i_factories.IndicatorFactory(program=self.program) self.targets = [] self.data = []
def setUpTestData(cls): program = w_factories.ProgramFactory( funding_status="funded", name="Test program name", reporting_period_start=datetime.date(2015, 1, 1), reporting_period_end=datetime.date(2017, 12, 31), _using_results_framework=Program.MIGRATED, auto_number_indicators=True ) i_factories.LevelTierFactory( program=program, tier_depth=1, name="Test Tier 1" ) i_factories.LevelTierFactory( program=program, tier_depth=2, name="Test Tier 2" ) level = i_factories.LevelFactory( program=program, name="Test Output Level", customsort=1, parent=i_factories.LevelFactory( name="Test Goal Level", program=program, customsort=1, parent=None, ), assumptions=', '.join(['assuming']*10) ) indicators = [ i_factories.IndicatorFactory( pk=21, program=program, level=level, level_order=0, means_of_verification=None, number="1.23a" ), i_factories.IndicatorFactory( pk=22, program=program, level=level, level_order=1, means_of_verification="some means here", number="2.444ab" ), i_factories.IndicatorFactory( pk=23, program=program, level=None, level_order=1, means_of_verification=', '.join(["some means here"]*10), number="4.444asdf" ) ] cls.program = program cls.level = level cls.indicators = indicators
def test_time_aware_indicators_no_completed_periods(self): # if program started yesterday then no targets will be finished by today: today = datetime.date.today() - datetime.timedelta(days=1) self.program = w_factories.ProgramFactory( reporting_period_start=datetime.date(today.year, today.month, 1), reporting_period_end=datetime.date(today.year+1, today.month, 1) - datetime.timedelta(days=1) ) for frequency in [freq for freq in self.TIME_AWARE_FREQUENCIES if freq != Indicator.MONTHLY]: # the above hack brought to you by the fact that once a month it is impossible to make a monthly indicator # with no completed programs. I apologize. self.load_base_indicator() self.indicator.target_frequency = frequency self.indicator.save() self.load_targets() self.load_data(date=datetime.date.today()-datetime.timedelta(days=1)) program = self.get_annotated_program() self.assertEqual( program.scope_counts['nonreporting_count'], 1, '{frequency} frequency indicator got scope counts {sc} instead of 1 nonreporting'.format( frequency=frequency, sc=program.scope_counts )) for target in self.targets: target.delete() self.targets = [] self.indicator.delete() self.indicator = None
def test_end_date_will_change_to_after_last_time_aware_target_set(self): program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2015, 1, 1), reporting_period_end=datetime.date(2017, 12, 31) ) indicator = i_factories.IndicatorFactory( target_frequency=Indicator.ANNUAL, program=program ) for start, end in [(datetime.date(2015, 1, 1), datetime.date(2015, 12, 31)), (datetime.date(2016, 1, 1), datetime.date(2016, 12, 31)), (datetime.date(2017, 1, 1), datetime.date(2017, 12, 31))]: i_factories.PeriodicTargetFactory( start_date=start, end_date=end, indicator=indicator ) response = self.client.post(reverse('reportingperiod_update', kwargs={'pk': program.pk}), {'reporting_period_start': '2015-01-01', 'reporting_period_end': '2017-10-31', 'rationale': 'test'}) self.assertEqual(json.loads(response.content)['msg'], 'success') self.assertEqual(len(json.loads(response.content)['failmsg']), 0) self.assertEqual(response.status_code, 200) refreshed = Program.objects.get(pk=program.pk) self.assertEqual(refreshed.reporting_period_start, datetime.date(2015, 1, 1)) self.assertEqual(refreshed.reporting_period_end, datetime.date(2017, 10, 31))
def test_start_date_does_change_if_no_time_aware_target_set(self): program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2015, 1, 1), reporting_period_end=datetime.date(2017, 12, 31) ) indicator = i_factories.IndicatorFactory( target_frequency=Indicator.MID_END, program=program ) i_factories.PeriodicTargetFactory( start_date=None, end_date=None, customsort=0, indicator=indicator ) response = self.client.post(reverse('reportingperiod_update', kwargs={'pk': program.pk}), {'reporting_period_start': '2016-01-01', 'reporting_period_end': '2017-12-31', 'rationale': 'test'}) self.assertEqual(json.loads(response.content)['msg'], 'success') self.assertEqual(len(json.loads(response.content)['failmsg']), 0) self.assertEqual(response.status_code, 200) refreshed = Program.objects.get(pk=program.pk) self.assertEqual(refreshed.reporting_period_start, datetime.date(2016, 1, 1)) self.assertEqual(refreshed.reporting_period_end, datetime.date(2017, 12, 31))
def test_start_date_to_reporting_date(self): program = w_factories.ProgramFactory( start_date=datetime.date(2018, 6, 15), end_date=datetime.date(2019, 12, 14) ) reporting_dates = util.get_reporting_dates(program) self.assertEqual(reporting_dates['reporting_period_start'], datetime.date(2018, 6, 1)) self.assertEqual(reporting_dates['reporting_period_end'], datetime.date(2019, 12, 31))
def setUp(self): self.user = w_factories.TolaUserFactory() self.client = test.Client() self.client.force_login(self.user.user) self.response = None self.program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2017, 2, 1), reporting_period_end=datetime.date(2019, 10, 31))
def test_program_with_non_time_aware_indicators_returns_none(self): for frequency in [Indicator.LOP, Indicator.MID_END, Indicator.EVENT]: program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2015, 1, 1), reporting_period_end=datetime.date(2017, 12, 31) ) i_factories.IndicatorFactory( target_frequency=frequency, program=program ) self.assertIsNone(program.last_time_aware_indicator_start_date)
def get_programs_for_country(country): two_indicator_program = w_factories.ProgramFactory( funding_status="Funded", reporting_period_start=start_date, reporting_period_end=end_date) two_indicator_program.country.set([country]) one_indicator_program = w_factories.ProgramFactory( funding_status="Funded", reporting_period_start=start_date, reporting_period_end=end_date) one_indicator_program.country.set([country]) zero_indicator_program = w_factories.ProgramFactory( funding_status="Funded", reporting_period_start=start_date, reporting_period_end=end_date) zero_indicator_program.country.set([country]) i_factories.IndicatorFactory(program=two_indicator_program) i_factories.IndicatorFactory(program=two_indicator_program) i_factories.IndicatorFactory(program=one_indicator_program) return two_indicator_program.id, one_indicator_program.id, zero_indicator_program.id
def test_program_with_all_indicators_returns_true(self): program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2015, 1, 1), reporting_period_end=datetime.date(2017, 12, 31) ) for frequency, _ in Indicator.TARGET_FREQUENCIES: i_factories.IndicatorFactory( target_frequency=frequency, program=program ) self.assertTrue(program.has_time_aware_targets)
def test_various_end_date_conversions(self): for end, reporting in [ (datetime.date(2014, 1, 1), datetime.date(2014, 1, 31)), (datetime.date(2015, 10, 13), datetime.date(2015, 10, 31)), (datetime.date(2016, 10, 30), datetime.date(2016, 10, 31)), (datetime.date(2017, 12, 31), datetime.date(2017, 12, 31)) ]: program = w_factories.ProgramFactory( start_date=datetime.date(2013, 1, 1), end_date=end ) reporting_dates = util.get_reporting_dates(program) self.assertEqual(reporting_dates['reporting_period_end'], reporting)
def test_reporting_period_updates_with_good_both_data(self): program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2015, 1, 1), reporting_period_end=datetime.date(2017, 12, 31) ) response = self.client.post(reverse('reportingperiod_update', kwargs={'pk': program.pk}), {'reporting_period_start': '2014-02-01', 'reporting_period_end': '2018-10-31'}) self.assertEqual(json.loads(response.content)['msg'], 'success') self.assertEqual(response.status_code, 200) refreshed = Program.objects.get(pk=program.pk) self.assertEqual(refreshed.reporting_period_start, datetime.date(2014, 2, 1)) self.assertEqual(refreshed.reporting_period_end, datetime.date(2018, 10, 31))
def test_reporting_period_does_not_update_with_bad_end_data(self): program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2015, 1, 1), reporting_period_end=datetime.date(2017, 12, 31) ) response = self.client.post(reverse('reportingperiod_update', kwargs={'pk': program.pk}), {'reporting_period_start': '2015-01-01', 'reporting_period_end': '2017-10-15'}) self.assertEqual(json.loads(response.content)['msg'], 'fail') self.assertEqual(len(json.loads(response.content)['failmsg']), 1) self.assertEqual(response.status_code, 422) refreshed = Program.objects.get(pk=program.pk) self.assertEqual(refreshed.reporting_period_start, datetime.date(2015, 1, 1)) self.assertEqual(refreshed.reporting_period_end, datetime.date(2017, 12, 31))
def test_lop_indicator_in_open_program(self): # get open (reporting period not over) program: # set dates from today so test doesn't become obsolete at some arbitrary future date: start_date = datetime.date.today() - datetime.timedelta(days=10) end_date = datetime.date.today() + datetime.timedelta(days=100) self.program = w_factories.ProgramFactory( reporting_period_start=start_date, reporting_period_end=end_date) self.load_base_indicator() self.indicator.target_frequency = Indicator.LOP # lop_target and data should be set to ensure it's only program openness restricting from "complete" self.indicator.lop_target = 1000 self.indicator.save() self.load_data() indicator = self.get_annotated_indicator() self.assertFalse(indicator.reporting)
def setUp(self): self.program = w_factories.ProgramFactory( reporting_period_start=datetime.date.today() - datetime.timedelta(days=365), reporting_period_end=datetime.date.today() - datetime.timedelta(days=1)) self.indicators = [] self.data = [] self.targets = [] self.indicators.extend(self.get_on_target_indicators()) self.indicators.extend(self.get_undertarget_indicators()) self.indicators.extend(self.get_overtarget_indicators()) self.indicators.extend(self.get_nonreporting_indicators()) with self.assertNumQueries(2): self.reporting_program = ProgramWithMetrics.home_page.with_annotations( 'scope').get(pk=self.program.id)
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 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 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 setUp(self): self.program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2016, 1, 1), reporting_period_end=datetime.date(2016, 12, 31), ) self.indicator = i_factories.IndicatorFactory( program=self.program, target_frequency=Indicator.LOP) self.tola_user = w_factories.TolaUserFactory() self.user = self.tola_user.user self.request = type('Request', (object, ), { 'has_write_access': True, 'user': self.user })() self.form_kwargs = { 'user': self.user, 'indicator': self.indicator, 'program': self.program, 'request': self.request, }
def setUpTestData(cls): cls.country = w_factories.CountryFactory() cls.user = w_factories.TolaUserFactory() cls.user.countries.add(cls.country) for case in cls.expected_cases: program = w_factories.ProgramFactory( reporting_period_start=cls.program_start_date, reporting_period_end=cls.program_end_date, funding_status='Funded', name=case['name']) program.country.add(cls.country) for c in range(case['indicator_count']): data_count = 0 indicator = do_add_indicator(program) if c < case['targets_defined']: do_add_defined_target(indicator) if c < case['reported_results']: collect_date = cls.collect_date + datetime.timedelta( days=data_count) data_count += 1 result = do_add_reported_result(indicator, collect_date, program) if c < case['results_evidence']: do_add_evidence(result, program)
def get_closed_program(self): self.program = w_factories.ProgramFactory( reporting_period_start=datetime.date(2016, 1, 1), reporting_period_end=datetime.date(2016, 12, 31) )
def get_program(self): return w_factories.ProgramFactory( reporting_period_start=self.program_dates[0], reporting_period_end=self.program_dates[1])