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')
