def setUp(self): self.program = ProgramFactory( reporting_period_start=get_date(dates['program_start']), reporting_period_end=get_date(dates['program_end'])) self.indicator = None self.targets = [] self.data = []
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 test_get_by_status(self): prog_completed = ProgramFactory(name='This fund is completed', funding_status='Completed') prog_closed = ProgramFactory(name='This fund is closed', funding_status='Closed') url = reverse_lazy(self.base_url, args=self.base_args) response = self.client.get(url) self.assertNotContains(response, prog_completed.name) self.assertNotContains(response, prog_closed.name)
def setUp(self): self.client = test.Client(enforce_csrf_checks=False) self.response = None startdate = datetime.strptime('2017-02-04', '%Y-%m-%d') enddate = datetime.strptime('2019-10-01', '%Y-%m-%d') self.program = ProgramFactory(reporting_period_start=startdate, reporting_period_end=enddate) self.request_params = { 'csrfmiddlewaretoken': 'asdf', 'program': self.program.id }
def setUp(self): self.user = UserFactory(first_name="PeterPeter", last_name="PumpkinEater", username="******") self.user.set_password('orangethumb') 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() # TolaUser not available on User if not logged in self.client.login(username=self.user.username, password='******')
def scenario_asserts(self, scenario): program = ProgramFactory(reporting_period_start=scenario['start'], reporting_period_end=scenario['end']) periods = [ x for x in program.get_periods_for_frequency(scenario['frequency']) ] self.assertEqual(len(periods), len(scenario['expected_names'])) for x, name in enumerate(scenario['expected_names']): if name: self.assertEqual(periods[x]['name'], name) for x, start in enumerate(scenario['expected_starts']): if start: self.assertEqual(periods[x]['start'], start) for x, end in enumerate(scenario['expected_ends']): if end: self.assertEqual(periods[x]['end'], end)
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 setUp(self): self.program = ProgramFactory() self.url = '/api/programtargetfrequencies/?program_id={pk}'.format( pk=self.program.pk) user = UserFactory() self.client = Client() self.client.force_login(user=user)
def setUp(self): self.client = test.Client(enforce_csrf_checks=False) self.response = None startdate = datetime.strptime('2017-02-04', '%Y-%m-%d') enddate = datetime.strptime('2019-10-01', '%Y-%m-%d') self.program = ProgramFactory(reporting_period_start=startdate, reporting_period_end=enddate)
def scenario_asserts(self, scenario): program = ProgramFactory( reporting_period_start=scenario['start'], reporting_period_end=scenario['end'] ) periods = [x for x in program.get_periods_for_frequency(scenario['frequency'])] self.assertEqual(len(periods), len(scenario['expected_names'])) # testing name tests a deprecated functionality (internationalization precludes storing names in DB): # for x, name in enumerate(scenario['expected_names']): # if name: # self.assertEqual(periods[x]['name'], name) for x, start in enumerate(scenario['expected_starts']): if start: self.assertEqual(periods[x]['start'], start) for x, end in enumerate(scenario['expected_ends']): if end: self.assertEqual(periods[x]['end'], end)
class CSVTestBase(test.TestCase): reporrtype = 'timeperiods' url = '/indicators/iptt_csv/{0}/{1}/' fields = ['id', 'number', 'name', 'level_name', 'unit_of_measure', 'unit_of_measure_type', 'sector', 'disaggregations', 'baseline', 'baseline_na', 'lop_target', 'target_frequency'] data_fields = ['lop_sum', 'lop_target', 'lop_met'] def setUp(self): self.client = test.Client() self.program = ProgramFactory(reporting_period_start=datetime.strptime('2017-01-01', '%Y-%m-%d'), reporting_period_end=datetime.strptime('2017-12-31', '%Y-%m-%d')) self.url = self.url.format(self.program.id, self.reporrtype) def tearDown(self): self.program.delete() def get_field(self, field, row): return row[ {v: c for c, v in enumerate(self.fields)}[field] ]
def setUp(self): self.user = UserFactory(first_name="FN", last_name="LN", username="******", is_superuser=True) self.user.set_password('password') self.user.save() self.tola_user = TolaUserFactory(user=self.user) self.tola_user.save() self.client = test.Client(enforce_csrf_checks=False) self.client.login(username='******', password='******') self.response = None startdate = datetime.strptime('2017-02-04', '%Y-%m-%d') enddate = datetime.strptime('2019-10-01', '%Y-%m-%d') self.program = ProgramFactory(reporting_period_start=startdate, reporting_period_end=enddate) self.request_params = { 'csrfmiddlewaretoken': 'asdf', 'program': self.program.id }
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))))
class TestIPTTReportviewURL(test.TestCase): def setUp(self): self.user = UserFactory(first_name="PeterPeter", last_name="PumpkinEater", username="******") self.user.set_password('orangethumb') 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 = test.RequestFactory() self.client = test.Client() self.client.login(username=self.user.username, password='******') def test_get(self): """Does get return 200 and the right template?""" url_kwargs = { 'program': self.program.id, 'reporttype': 'targetperiods', } filterdata = {'frequency': 3, 'timeframe': 1} path = reverse_lazy('iptt_report', kwargs=url_kwargs) response = self.client.get(path, data=filterdata, follow=True) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, template_name=IPTTReport.template_name)
def test_generate_target_periods_midend(self): program = ProgramFactory( reporting_period_start=datetime.date(2015, 4, 1), reporting_period_end=datetime.date(2016, 6, 30)) mixin = IPTT_Mixin() mixin.program = program mixin.filter_form_initial_data = {'timeframe': 1} (end_date, date_ranges, targetperiods) = mixin._generate_targetperiods(Indicator.MID_END) self.assertEqual(end_date, datetime.date(2016, 6, 30)) self.assertEqual(len(date_ranges), 1) self.assertEqual(date_ranges[0]['start'], datetime.date(2015, 4, 1)) self.assertEqual(date_ranges[0]['end'], datetime.date(2016, 6, 30)) self.assertEqual(len(targetperiods), 2)
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 test_generate_target_periods_annual(self): # program with 5 year period program = ProgramFactory( reporting_period_start=datetime.date(2013, 1, 1), reporting_period_end=datetime.date(2017, 12, 31)) mixin = IPTT_Mixin() mixin.program = program mixin.filter_form_initial_data = {'timeframe': 1} (end_date, date_ranges, targetperiods) = mixin._generate_targetperiods(Indicator.ANNUAL) self.assertEqual(end_date, datetime.date(2017, 12, 31)) self.assertEqual(len(date_ranges), 5) self.assertEqual(date_ranges[1]['start'], datetime.date(2014, 1, 1)) self.assertEqual(len(targetperiods), 5) mixin.filter_form_initial_data = { 'timeframe': 0, 'start_period': '2013-01-01', 'end_period': '2016-12-31' } (end_date, date_ranges, targetperiods) = mixin._generate_targetperiods(Indicator.ANNUAL) self.assertEqual(end_date, datetime.date(2016, 12, 31)) self.assertEqual(len(date_ranges), 5) self.assertEqual(len(targetperiods), 4) mixin.filter_form_initial_data = { 'timeframe': 0, 'start_period': '2013-01-01', 'end_period': '2014-12-31' } (end_date, date_ranges, targetperiods) = mixin._generate_targetperiods(Indicator.ANNUAL) self.assertEqual(end_date, datetime.date(2014, 12, 31)) self.assertEqual(len(date_ranges), 5) self.assertEqual(len(targetperiods), 2) mixin.filter_form_initial_data = { 'timeframe': 2, 'numrecentperiods': 3 } (end_date, date_ranges, targetperiods) = mixin._generate_targetperiods(Indicator.ANNUAL) self.assertEqual(end_date, datetime.date(2017, 12, 31)) self.assertEqual(len(date_ranges), 5) self.assertEqual(len(targetperiods), 3) self.assertEqual(targetperiods[0]['start'], datetime.date(2015, 1, 1))
def test_generate_target_periods_quarterly(self): program = ProgramFactory( reporting_period_start=datetime.date(2015, 4, 1), reporting_period_end=datetime.date(2016, 6, 30)) mixin = IPTT_Mixin() mixin.program = program mixin.filter_form_initial_data = {'timeframe': 1} (end_date, date_ranges, targetperiods) = mixin._generate_targetperiods(Indicator.QUARTERLY) self.assertEqual(end_date, datetime.date(2016, 6, 30)) self.assertEqual(len(date_ranges), 5) self.assertEqual(date_ranges[1]['start'], datetime.date(2015, 7, 1)) self.assertEqual(len(targetperiods), 5) mixin.filter_form_initial_data = { 'timeframe': 0, 'start_period': '2015-04-01', 'end_period': '2015-12-31' } (end_date, date_ranges, targetperiods) = mixin._generate_targetperiods(Indicator.QUARTERLY) self.assertEqual(end_date, datetime.date(2015, 12, 31)) self.assertEqual(len(date_ranges), 5) self.assertEqual(len(targetperiods), 3) mixin.filter_form_initial_data = { 'timeframe': 0, 'start_period': '2015-10-01', 'end_period': '2016-3-31' } (end_date, date_ranges, targetperiods) = mixin._generate_targetperiods(Indicator.QUARTERLY) self.assertEqual(end_date, datetime.date(2016, 3, 31)) self.assertEqual(targetperiods[1]['name'], 'Quarter 4') self.assertEqual(len(date_ranges), 5) self.assertEqual(len(targetperiods), 2) mixin.filter_form_initial_data = { 'timeframe': 2, 'numrecentperiods': 3 } (end_date, date_ranges, targetperiods) = mixin._generate_targetperiods(Indicator.QUARTERLY) self.assertEqual(end_date, datetime.date(2016, 6, 30)) self.assertEqual(len(date_ranges), 5) self.assertEqual(targetperiods[0]['name'], 'Quarter 3') self.assertEqual(len(targetperiods), 3) self.assertEqual(targetperiods[0]['start'], datetime.date(2015, 10, 1))
def test_generate_timeperiods(self): program = ProgramFactory( reporting_period_start=datetime.date(2015, 1, 1), reporting_period_end=datetime.date(2016, 12, 31)) mixin = IPTT_Mixin() mixin.program = program mixin.filter_form_initial_data = {'timeframe': 1} (end_date, date_ranges, targetperiods) = mixin._generate_timeperiods() self.assertEqual(end_date, datetime.date(2016, 12, 31)) self.assertEqual(len(date_ranges), 24) self.assertEqual(len(targetperiods), 24) self.assertEqual(date_ranges[9]['start'], datetime.date(2015, 10, 1)) mixin.filter_form_initial_data = { 'timeframe': 0, 'start_period': '2015-10-1', 'end_period': '2016-12-31' } (end_date, date_ranges, targetperiods) = mixin._generate_timeperiods() self.assertEqual(end_date, datetime.date(2016, 12, 31)) self.assertEqual(len(date_ranges), 24) self.assertEqual(len(targetperiods), 15) self.assertEqual(targetperiods[9]['start'], datetime.date(2016, 7, 1)) mixin.filter_form_initial_data = { 'timeframe': 0, 'start_period': '2015-10-1', 'end_period': '2016-10-31' } (end_date, date_ranges, targetperiods) = mixin._generate_timeperiods() self.assertEqual(end_date, datetime.date(2016, 10, 31)) self.assertEqual(len(date_ranges), 24) self.assertEqual(len(targetperiods), 13) self.assertEqual(targetperiods[-1]['start'], datetime.date(2016, 10, 1)) mixin.filter_form_initial_data = { 'timeframe': 2, 'numrecentperiods': 4 } (end_date, date_ranges, targetperiods) = mixin._generate_timeperiods(Indicator.MONTHLY) self.assertEqual(end_date, datetime.date(2016, 12, 31)) self.assertEqual(len(date_ranges), 24) self.assertEqual(len(targetperiods), 4) self.assertEqual(targetperiods[0]['start'], datetime.date(2016, 9, 1))
def setUp(self): self.client = Client() self.program = ProgramFactory() self.user = UserFactory()
class TestIPTTTimePeriodsReportResponseBase(test.TestCase): timeperiods = Indicator.ANNUAL def setUp(self): self.user = UserFactory(first_name="FN", last_name="LN", username="******", is_superuser=True) self.user.set_password('password') self.user.save() self.tola_user = TolaUserFactory(user=self.user) self.tola_user.save() self.client = test.Client(enforce_csrf_checks=False) self.client.login(username='******', password='******') self.response = None startdate = datetime.strptime('2017-02-04', '%Y-%m-%d') enddate = datetime.strptime('2019-10-01', '%Y-%m-%d') self.program = ProgramFactory(reporting_period_start=startdate, reporting_period_end=enddate) self.request_params = { 'csrfmiddlewaretoken': 'asdf', 'program': self.program.id } def tearDown(self): Indicator.objects.all().delete() self.response = None def set_dates(self, start, end): self.program.reporting_period_start = datetime.strptime( start, '%Y-%m-%d') self.program.reporting_period_end = datetime.strptime(end, '%Y-%m-%d') self.program.save() 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, frequency=Indicator.ANNUAL, **kwargs): kwargs['target_frequency'] = frequency return self.get_indicator_for_program(**kwargs) def add_indicator_with_data(self, frequency, values): indicator = self.add_indicator(frequency=frequency) collect_date = self.program.reporting_period_start + timedelta(days=1) for value in values: _ = ResultFactory(indicator=indicator, date_collected=collect_date, achieved=value) if frequency == Indicator.ANNUAL: collect_date = datetime(collect_date.year + 1, collect_date.month, collect_date.day) elif frequency == Indicator.SEMI_ANNUAL: collect_date = datetime( collect_date.year if collect_date.month < 7 else collect_date.year + 1, collect_date.month + 6 if collect_date.month < 7 else collect_date.month - 6, collect_date.day) elif frequency == Indicator.TRI_ANNUAL: collect_date = datetime( collect_date.year if collect_date.month < 9 else collect_date.year + 1, collect_date.month + 4 if collect_date.month < 9 else collect_date.month - 8, collect_date.day) elif frequency == Indicator.QUARTERLY: collect_date = datetime( collect_date.year if collect_date.month < 10 else collect_date.year + 1, collect_date.month + 3 if collect_date.month < 10 else collect_date.month - 9, collect_date.day) elif frequency == Indicator.MONTHLY: collect_date = datetime( collect_date.year if collect_date.month < 12 else collect_date.year + 1, collect_date.month + 1 if collect_date.month < 12 else collect_date.month - 11, collect_date.day) def get_showall_response(self): self.request_params['timeframe'] = 1 self.request_params['numrecentperiods'] = None return self.get_response() def get_recent_periods(self, numrecent): self.request_params['timeframe'] = 2 self.request_params['numrecentperiods'] = numrecent return self.get_response() def get_date_range_periods(self, start, end): self.request_params['start_period'] = start.strftime( '%Y-%m-%d') if isinstance(start, datetime) else start self.request_params['end_period'] = end.strftime( '%Y-%m-%d') if isinstance(end, datetime) else end return self.get_response() def get_response(self, reporttype=IPTT_Mixin.REPORT_TYPE_TIMEPERIODS): self.request_params['timeperiods'] = self.timeperiods response = self.client.post( '/indicators/iptt_report/{program}/{reporttype}/'.format( program=self.program.id, reporttype=reporttype), self.request_params, follow=True) self.assertEqual( response.status_code, 200, "response gave status code {0} instead of 200".format( response.status_code)) self.response = IPTTResponse(response.content, timeperiods=True) return self.response def get_indicator_results(self, response, indicator_row=0): indicator = response.indicators[indicator_row]['ranges'] return indicator[0], indicator[1:] def format_assert_message(self, msg): return "{0}:\n{1} timeperiods, {2}".format(self.response, { k: v for k, v in Indicator.TARGET_FREQUENCIES }[self.timeperiods], msg) def number_of_ranges_test(self, start, end, expected_ranges): self.set_dates(start, end) self.add_indicator() response = self.get_showall_response() ranges = response.indicators[0]['ranges'][1:] self.assertEqual( len(ranges), expected_ranges, self.format_assert_message( "expected {0} ranges for {1} to {2}, got {3}".format( expected_ranges, start, end, len(ranges))))
class IPTT_MixinTests(TestCase): """Test private methods not specifically tested in other test cases""" freqs = { Indicator.ANNUAL: 12, Indicator.SEMI_ANNUAL: IPTT_Mixin.MONTHS_PER_SEMIANNUAL, Indicator.TRI_ANNUAL: IPTT_Mixin.MONTHS_PER_TRIANNUAL, Indicator.QUARTERLY: IPTT_Mixin.MONTHS_PER_QUARTER, Indicator.MONTHLY: IPTT_Mixin.MONTHS_PER_MONTH, # Indicator.LOP, Indicator.MID_END, Indicator.EVENT } def setUp(self): self.mixin = IPTT_Mixin() self.user = UserFactory(first_name="Indy", last_name="Cater", 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-04-01', reporting_period_end='2020-06-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.LOP) self.request_factory = RequestFactory() self.client = Client() self.client.login(username="******", password='******') def test__get_num_months(self): """Do we return the right number of months per period?""" for freq in IPTT_MixinTests.freqs: num_months_in_period = self.mixin._get_num_months(freq) self.assertEqual(num_months_in_period, IPTT_MixinTests.freqs[freq]) def test__get_num_periods_returns_0_for_reversed_date_range(self): """Do we return if end date is before start date?""" _get_num_periods = IPTT_Mixin._get_num_periods start_date = date(2020, 1, 1) end_date = date(2019, 1, 1) self.assertEqual( _get_num_periods(start_date, end_date, Indicator.ANNUAL), 0) self.assertEqual( _get_num_periods(start_date, end_date, Indicator.SEMI_ANNUAL), 0) self.assertEqual( _get_num_periods(start_date, end_date, Indicator.TRI_ANNUAL), 0) self.assertEqual( _get_num_periods(start_date, end_date, Indicator.QUARTERLY), 0) self.assertEqual( _get_num_periods(start_date, end_date, Indicator.MONTHLY), 0) def test__get_period_name(self): """Do we return the correct period names?""" _get_period_name = IPTT_Mixin._get_period_name self.assertEqual(_get_period_name(Indicator.ANNUAL), "Year") self.assertEqual(_get_period_name(Indicator.SEMI_ANNUAL), "Semi-annual") self.assertEqual(_get_period_name(Indicator.TRI_ANNUAL), "Tri-annual") self.assertEqual(_get_period_name(Indicator.QUARTERLY), "Quarter") self.assertEqual(_get_period_name(Indicator.MONTHLY), "Month") def test__get_first_period(self): """Do we calculate the first period of a date range correctly?""" real_start_date = date(2016, 7, 15) for freq in IPTT_MixinTests.freqs: num_months = self.mixin._get_num_months(freq) _get_first_period = self.mixin._get_first_period( real_start_date, num_months) if freq == Indicator.ANNUAL: self.assertEqual(_get_first_period, date(2016, 1, 1)) elif freq == Indicator.SEMI_ANNUAL: self.assertEqual(_get_first_period, date(2016, 7, 1)) elif freq == Indicator.TRI_ANNUAL: self.assertEqual(_get_first_period, date(2016, 5, 1)) elif freq == Indicator.QUARTERLY: self.assertEqual(_get_first_period, date(2016, 7, 1)) elif freq == Indicator.MONTHLY: self.assertEqual(_get_first_period, date(2016, 7, 1)) else: self.fail('Unexpected target frequency' + freq) def test__generate_annotations(self): """Do we generate queryset annotations correctly?""" reporttype = 'timeperiods' filter_start_date = date(2018, 1, 1) filter_end_date = date(2019, 12, 31) num_recents = 0 show_all = True self.mixin.program = Program() self.mixin.program.reporting_period_start = filter_start_date self.mixin.program.reporting_period_end = filter_end_date freqs = (Indicator.LOP, Indicator.MID_END, Indicator.EVENT, Indicator.ANNUAL, Indicator.SEMI_ANNUAL, Indicator.TRI_ANNUAL, Indicator.QUARTERLY, Indicator.MONTHLY) for freq in freqs: (report_end_date, all_date_ranges, periods_date_ranges) = self.mixin._generate_targetperiods( Indicator.MONTHLY) self.assertEqual(self.mixin.program.reporting_period_end, report_end_date) self.assertEqual(self.mixin.program.reporting_period_end, filter_end_date) annotations = self.mixin._generate_annotations( periods_date_ranges, freq, reporttype) if freq == Indicator.LOP: self.assertEqual(annotations, {}) else: self.assertNotEqual(annotations, {}) def test__get_num_periods(self): """Do we return the correct number of periods""" _get_num_periods = IPTT_Mixin._get_num_periods start_date = date(2016, 1, 15) end_date = date(2017, 12, 16) self.assertEqual( _get_num_periods(start_date, end_date, Indicator.ANNUAL), 2) self.assertEqual( _get_num_periods(start_date, end_date, Indicator.SEMI_ANNUAL), 4) self.assertEqual( _get_num_periods(start_date, end_date, Indicator.TRI_ANNUAL), 6) self.assertEqual( _get_num_periods(start_date, end_date, Indicator.QUARTERLY), 8) self.assertEqual( _get_num_periods(start_date, end_date, Indicator.MONTHLY), 24) @unittest.skip('outdated test') def test__generate_targetperiods(self): """Can we generate target periods correctly""" freqs = (Indicator.LOP, Indicator.MID_END, Indicator.EVENT, Indicator.ANNUAL, Indicator.SEMI_ANNUAL, Indicator.TRI_ANNUAL, Indicator.QUARTERLY, Indicator.MONTHLY) self.mixin.filter_form_initial_data = { 'timeframe': 1, 'numrecentperiods': 0, 'period_start': '2018-01-01', 'period_end': '2019-12-31' } filter_start_date = date(2018, 1, 1) filter_end_date = date(2019, 12, 31) num_recents = 0 show_all = True self.mixin.program = Program() self.mixin.program.reporting_period_start = filter_start_date self.mixin.program.reporting_period_end = filter_end_date for freq in freqs: report_end_date, all_date_ranges, targetperiods = self.mixin._generate_targetperiods( freq) self.assertEqual(filter_end_date, report_end_date) self.assertEqual(len(all_date_ranges), 0) self.assertEqual(len(targetperiods), 0) @unittest.skip('outdated test') def test__generate_timeperiods(self): """Can we generate time periods correctly?""" freqs = (Indicator.LOP, Indicator.MID_END, Indicator.EVENT, Indicator.ANNUAL, Indicator.SEMI_ANNUAL, Indicator.TRI_ANNUAL, Indicator.QUARTERLY, Indicator.MONTHLY) filter_start_date = date(2018, 1, 1) filter_end_date = date(2019, 12, 31) num_recents = 0 self.mixin.filter_form_initial_data = { 'timeframe': 1, 'numrecentperiods': num_recents, 'period_start': '2018-01-01', 'period_end': '2019-12-31' } self.mixin.program = Program() self.mixin.program.reporting_period_start = filter_start_date self.mixin.program.reporting_period_end = filter_end_date for freq in freqs: report_end_date, all_date_ranges, timeperiods = self.mixin._generate_targetperiods( Indicator.MONTHLY) self.assertEqual(report_end_date, filter_end_date, 'End dates don\'t match') if freq == Indicator.LOP or freq == Indicator.MID_END or freq == Indicator.EVENT: self.assertEqual(len(all_date_ranges), 0) elif freq == Indicator.ANNUAL: self.assertEqual( len(all_date_ranges), 2, 'Unexpected number of date ranges for {0}: {1}'.format( freq, len(all_date_ranges))) self.assertEqual( len(timeperiods), 2, 'Unexpected number of timeperiods for {0}: {1}'.format( freq, len(timeperiods))) elif freq == Indicator.SEMI_ANNUAL: self.assertEqual( len(all_date_ranges), 4, 'Unexpected number of date ranges for {0}: {1}'.format( freq, len(all_date_ranges))) self.assertEqual( len(timeperiods), 4, 'Unexpected number of timeperiods for {0}: {1}'.format( freq, len(timeperiods))) elif freq == Indicator.TRI_ANNUAL: self.assertEqual( len(all_date_ranges), 6, 'Unexpected number of date ranges for {0}: {1}'.format( freq, len(all_date_ranges))) self.assertEqual( len(timeperiods), 6, 'Unexpected number of timeperiods for {0}: {1}'.format( freq, len(timeperiods))) elif freq == Indicator.QUARTERLY: self.assertEqual( len(all_date_ranges), 8, 'Unexpected number of date ranges for {0}: {1}'.format( freq, len(all_date_ranges))) self.assertEqual( len(timeperiods), 8, 'Unexpected number of timeperiods for {0}: {1}'.format( freq, len(timeperiods))) elif freq == Indicator.MONTHLY: self.assertEqual( len(all_date_ranges), 24, 'Unexpected number of date ranges for {0}: {1}'.format( freq, len(all_date_ranges))) self.assertEqual( len(timeperiods), 24, 'Unexpected number of timeperiods for {0}: {1}'.format( freq, len(timeperiods))) def test__update_filter_form_initial(self): """Do we populate the initial filter form properly?""" data = { 'csrfmiddlewaretoken': 'lolwut', 'program': self.program.id, 'formprefix': IPTTReportQuickstartView.FORM_PREFIX_TARGET, 'timeframe': Indicator.LOP, 'targetperiods': 1, 'numrecentperiods': 1, } query_string = urllib.urlencode(data) formdata = QueryDict(query_string=query_string, mutable=True) self.mixin._update_filter_form_initial(formdata=formdata) filter_form_initial_data = self.mixin.filter_form_initial_data self.assertEqual(len(filter_form_initial_data), 4) self.assertNotIn('csrfmiddlewaretokeen', filter_form_initial_data) self.assertNotIn('program', filter_form_initial_data) # Dicts should have the same key/value pairs; the method first # strips off program and csrfmiddlewaretoken, so do that, too. del (data['csrfmiddlewaretoken']) del (data['program']) for k in data.keys(): self.assertIn(k, formdata) # Coercing both to str because the data arg is an int # and the formdata arg is a unicode value self.assertEqual(str(data[k]), str(formdata[k])) def test__get_filters_with_no_periods(self): data = { 'level': 3, 'sector': 'Conflict Management', # TODO: Load fixtures for level, indicators 'ind_type': 'Custom', 'site': self.program.country.name, 'indicators': self.indicator.id, } filters = self.mixin._get_filters(data) # Assert things about the returned filters self.assertEqual(len(filters), len(data)) self.assertIn(data['level'], filters['level__in']) self.assertIn(data['sector'], filters['sector__in']) self.assertIn(data['ind_type'], filters['indicator_type__in']) self.assertIn(data['site'], filters['result__site__in']) self.assertIn(data['indicators'], filters['id__in']) self.assertEqual(data['level'], *filters['level__in']) self.assertEqual(data['sector'], *filters['sector__in']) self.assertEqual(data['ind_type'], *filters['indicator_type__in']) self.assertEqual(data['site'], *filters['result__site__in']) self.assertEqual(data['indicators'], *filters['id__in']) # TODO: Is it possible to make assertions about the filtered report # TODO: without a GET or POST? def test_prepare_indicators(self): self.skipTest('TODO: Test not implemented') def test_prepare_iptt_period_dateranges(self): self.skipTest('TODO: Test not implemented') # TODO: Mock the super call that invokes a non-existent get_context_data # call on IPTT_Mixin. def test_get_context_data(self): '''Does get_context_data return existing data untouched and without inserting new data?''' self.skipTest('TODO: Test not implemented')
class TestIndicatorScenarios(test.TestCase): def setUp(self): self.program = ProgramFactory( reporting_period_start=get_date(dates['program_start']), reporting_period_end=get_date(dates['program_end'])) self.indicator = None self.targets = [] self.data = [] def tearDown(self): for data in self.data: data.delete() for target in self.targets: target.delete() if self.indicator is not None: self.indicator.delete() self.program.delete() 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 get_scenarios(self): for scenario in scenarios: try: self.indicator = self.indicator_for_scenario(scenario) except ValidationError: exc_type, exc_value = sys.exc_info()[:2] self.fail("{0} in {1} scenario: {2}".format( exc_type.__name__, scenario['desc'], ",".join(exc_value))) self.assertEqual(self.indicator.program, self.program) yield scenario def test_scenario_totals_targetperiods(self): settings.DEBUG = True for scenario in self.get_scenarios(): created = len(connection.queries) iptt_indicator = IPTTIndicator.withtargets.get( pk=self.indicator.pk) expected_queries = 2 self.assertLessEqual( len(connection.queries) - created, expected_queries, "Expecting {0} query to fetch indicator, but it took {1}". format(expected_queries, len(connection.queries) - created)) # make sure iptt indicator proxy loaded correctly: self.assertEqual(iptt_indicator.pk, self.indicator.pk) if scenario['blank']: # no tests on a blank (unsupported for annotations) indicator: return self.assertEqual( iptt_indicator.lop_target_sum, scenario['lop_target'], "In scenario {desc}: calculated lop_target_sum should be {1}, got {0}" .format(iptt_indicator.lop_target_sum, scenario['lop_target'], desc=scenario['desc'])) self.assertEqual( iptt_indicator.lop_actual_sum, scenario['lop_sum'], "In scenario {desc}: calculated lop sum should be {0}, got {1}" .format(scenario['lop_sum'], iptt_indicator.lop_actual_sum, desc=scenario['desc'])) self.assertEqual( iptt_indicator.lop_met_target, scenario['lop_met'], "In scenarios {desc}: lop met_target should be {0}, got {1}". format(scenario['lop_met'], iptt_indicator.lop_met_target, desc=scenario['desc'])) settings.DEBUG = False def test_scenario_totals_timeperiods(self): settings.DEBUG = True for scenario in self.get_scenarios(): created = len(connection.queries) iptt_indicator = IPTTIndicator.notargets.get(pk=self.indicator.pk) expected_queries = 1 self.assertLessEqual( len(connection.queries) - created, expected_queries, "Expecting {0} query to fetch indicator, but it took {1}". format(expected_queries, len(connection.queries) - created)) # make sure iptt indicator proxy loaded correctly: self.assertEqual(iptt_indicator.pk, self.indicator.pk) if scenario['blank']: # no tests on a blank (unsupported for annotations) indicator: return self.assertEqual( iptt_indicator.lop_target_sum, scenario['lop_target'], "In scenario {desc}: calculated lop_target_sum should be {1}, got {0}" .format(iptt_indicator.lop_target_sum, scenario['lop_target'], desc=scenario['desc'])) self.assertEqual( iptt_indicator.lop_actual_sum, scenario['lop_sum'], "In scenario {desc}: calculated lop sum should be {0}, got {1}" .format(scenario['lop_sum'], iptt_indicator.lop_actual_sum, desc=scenario['desc'])) self.assertEqual( iptt_indicator.lop_met_target, scenario['lop_met'], "In scenarios {desc}: lop met_target should be {0}, got {1}". format(scenario['lop_met'], iptt_indicator.lop_met_target, desc=scenario['desc'])) settings.DEBUG = False def test_periodic_target_scenarios(self): settings.DEBUG = True for scenario in self.get_scenarios(): created = len(connection.queries) indicator = IPTTIndicator.withtargets.get(pk=self.indicator.pk) expected_queries = 2 #one for each target self.assertLessEqual( len(connection.queries) - created, expected_queries, "Expecting {0} queries to fetch indicator, but it took {1}". format(expected_queries, len(connection.queries) - created)) if scenario['blank']: return self.assertEqual( len(indicator.data_targets), len(scenario['targets']), "In {desc}: expecting {0} indicator targets, got {1}".format( len(scenario['targets']), len(indicator.data_targets), desc=scenario['desc'])) for c, target_actual in enumerate(indicator.data_targets): self.assertEqual( target_actual.target, scenario['targets'][c], "In {desc}: expected {0} for target {1}, but got {2}". format(scenario['targets'][c], c, target_actual.target, desc=scenario['desc'])) self.assertEqual( target_actual.data_sum, scenario['results'][c], "In {desc}: expected a sum of {0} for target {1}, but got {2}" .format(scenario['results'][c], c, target_actual.data_sum, desc=scenario['desc'])) self.assertEqual( target_actual.met, scenario['mets'][c], "In {desc}: expected a met of {0} for target {1}, but got {2}" .format(scenario['mets'][c], c, target_actual.met, desc=scenario['desc'])) self.assertEqual( target_actual.within_target_range, scenario['over_under'][c], "In {desc}: expected {0} within_target_range to be {1}, got {2}" .format(c, scenario['over_under'][c], target_actual.within_target_range, desc=scenario['desc'])) self.assertLessEqual( len(connection.queries) - created, expected_queries, "(after all tests): expecting {0} queries to fetch indicator, but it took {1}" .format(expected_queries, len(connection.queries) - created)) settings.DEBUG = False def test_timeperiod_scenarios(self): settings.DEBUG = True periods = [{ 'start_date': datetime(2016, 1, 1), 'end_date': datetime(2016, 6, 30), }, { 'start_date': datetime(2016, 7, 1), 'end_date': datetime(2016, 12, 31) }] for scenario in self.get_scenarios(): created = len(connection.queries) indicator = IPTTIndicator.notargets.periods(periods).get( pk=self.indicator.id) expected_queries = 1 self.assertLessEqual( len(connection.queries) - created, expected_queries, "Expecting {0} queries to fetch indicator, but it took {1}". format(expected_queries, len(connection.queries) - created)) expected_results = len(scenario['semi_annual_results'] ) if not scenario['blank'] else 0 self.assertEqual( len([p for p in indicator.timeperiods]), expected_results, "In {desc}, expected {0} timeperiods, got {1}".format( expected_results, len([p for p in indicator.timeperiods]), desc=scenario['desc'])) for c, period in enumerate(periods): if scenario['blank'] != True: period_sum = getattr( indicator, "{0}-{1}".format( period['start_date'].strftime('%Y-%m-%d'), period['end_date'].strftime('%Y-%m-%d'))) self.assertEqual( period_sum, scenario['semi_annual_results'][c], "{desc} expected {0} for sum of semi annual period {1}, got {2}" .format(scenario['semi_annual_results'][c], c, period_sum, desc=scenario['desc'])) settings.DEBUG = False
def setUp(self): self.client = test.Client() self.program = ProgramFactory( reporting_period_start=datetime.strptime('2017-01-01', '%Y-%m-%d'), reporting_period_end=datetime.strptime('2017-12-31', '%Y-%m-%d')) self.url = self.url.format(self.program.id, self.reporrtype)
def setUp(self): self.program = ProgramFactory(reporting_period_start=date(2015, 1, 1), reporting_period_end=date(2019, 12, 31), name='Test Program Name') self.view = IPTT_ExcelExport()
class IPTT_ReportViewTests(TestCase): """Unit tests to validate IPTT_ReportView""" def setUp(self): self.user = UserFactory(first_name="PeterPeter", last_name="PumpkinEater", username="******") self.user.set_password('orangethumb') 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=self.user.username, password='******') def test_get(self): """Does get return 200 and the right template?""" url_kwargs = { 'program_id': self.program.id, 'reporttype': 'targetperiods', } filterdata = {'targetperiods': 1, 'timeframe': 1} path = reverse_lazy('iptt_report', kwargs=url_kwargs) response = self.client.get(path, data=filterdata, follow=True) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, template_name=IPTT_ReportView.template_name) # Verify that real program and indicator data are present self.assertIn(self.program.name, response.content) self.assertIn(self.indicator.name, response.content) # Dates come out the database as '2016-03-01' # Those dates are formatted as 'Mar 01, 2016' in the content expected_start = datetime.datetime.strptime( self.program.reporting_period_start, '%Y-%m-%d') expected_end = datetime.datetime.strptime( self.program.reporting_period_end, '%Y-%m-%d') # TODO: fails because l10n: self.assertIn(expected_start.strftime('%b %d, %Y'), response.content) # TODO: fails because l10n: self.assertIn(expected_end.strftime('%b %d, %Y'), response.content) def test_post(self): """Does post return 200 show the requested report?""" url_kwargs = { 'program_id': self.program.id, 'reporttype': 'targetperiods', } data = { 'csrfmiddlewaretoken': 'lolwut', 'program': self.program.id, 'targetperiods': 1, 'timeframe': 1, } path = reverse_lazy('iptt_report', kwargs=url_kwargs) response = self.client.post(path, data=data, follow=True) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.redirect_chain), 1) # Verify that real program and indicator data are present self.assertIn(self.program.name, response.content) self.assertIn(self.indicator.name, response.content) # Dates returned as '2016-03-01' # Present in content as 'Mar 01, 2016' exp_start = datetime.datetime.strptime( self.program.reporting_period_start, '%Y-%m-%d') exp_end = datetime.datetime.strptime(self.program.reporting_period_end, '%Y-%m-%d')
class IPTTReportQuickstartViewTests(TestCase): """Unit tests to valid the IPTTReportQuickStartView""" 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) lop_indicator = IndicatorFactory(program=self.program, target_frequency=Indicator.LOP) self.request_factory = RequestFactory() self.client = Client() self.client.login(username="******", password='******') def test_page_load_returns_200(self): """Do we return 200?""" response = self.client.get(reverse_lazy('iptt_quickstart')) self.assertEqual(response.status_code, 200) def test_page_load_does_not_redirect(self): """This page should not redirect""" response = self.client.get(reverse_lazy('iptt_quickstart'), follow=True) self.assertEqual(len(response.redirect_chain), 0) def test_page_loads_correct_template(self): """Do we load the right template?""" response = self.client.get(reverse_lazy('iptt_quickstart'), follow=True) self.assertTemplateUsed(response, 'indicators/iptt_quickstart.html') self.assertContains(response, 'Indicator Performance Tracking Table') def test_get_form_kwargs(self): """Do we get the correct form kwargs?""" data = { 'csrfmiddlewaretoken': 'lolwut', 'targetperiods-program': self.program.id, 'targetperiods-formprefix': IPTTReportQuickstartView.FORM_PREFIX_TARGET, 'targetperiods-timeframe': Indicator.LOP, 'targetperiods-targetperiods': 1, 'targetperiods-numrecentperiods': 1, } path = reverse_lazy('iptt_quickstart') response = self.client.post(path, data=data, follow=True) kwargs = response.resolver_match.kwargs self.assertEqual(kwargs['reporttype'], IPTTReportQuickstartView.FORM_PREFIX_TARGET) self.assertEqual(int(kwargs['program_id']), self.program.id) def test_get_context_data(self): """Do we get the correct context data?""" data = { 'csrfmiddlewaretoken': 'lolwut', 'targetperiods-program': self.program.id, 'targetperiods-formprefix': IPTTReportQuickstartView.FORM_PREFIX_TARGET, 'targetperiods-timeframe': Indicator.LOP, 'targetperiods-targetperiods': 1, 'targetperiods-numrecentperiods': 1, } path = reverse_lazy('iptt_quickstart') response = self.client.post(path, data=data, follow=True) context_data = response.context_data self.assertEqual(int(context_data['program_id']), self.program.id) # self.assertEqual(context['report_wide'], ?) # self.assertEqual(context['report_date_ranges'], ?) # self.assertEqual(context['indicators'], ?) self.assertRegex(str(context_data['program']), self.program.name) self.assertEqual(str(context_data['reporttype']), IPTTReportQuickstartView.FORM_PREFIX_TARGET) self.assertEqual(str(context_data['report_end_date']), self.program.reporting_period_end) self.assertEqual(str(context_data['report_end_date_actual']), self.program.reporting_period_end) self.assertEqual(str(context_data['report_start_date']), self.program.reporting_period_start) def test_post_with_valid_form(self): """Does POSTing to iptt_quickstart with valid form data redirect to the correct view (iptt_report)?""" data = { 'csrfmiddlewaretoken': 'lolwut', 'targetperiods-program': self.program.id, 'targetperiods-formprefix': IPTTReportQuickstartView.FORM_PREFIX_TARGET, 'targetperiods-timeframe': Indicator.LOP, 'targetperiods-targetperiods': 1, 'targetperiods-numrecentperiods': 1, } path = reverse_lazy('iptt_quickstart') response = self.client.post(path, data=data, follow=True) self.assertEqual(len(response.redirect_chain), 1) self.assertTemplateUsed(response, 'indicators/iptt_report.html') self.assertEqual(response.status_code, 200) def test_post_with_invalid_form(self): """Does POSTing to iptt_quickstart with crap form data leave us at iptt_quickstart?""" path = reverse_lazy('iptt_quickstart') response = self.client.post(path, data={'foo': 'bar'}) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'indicators/iptt_quickstart.html')