def setUp(self):
super(TestStateViewsFunctional, self).setUp()
with transaction.manager:
state = State(name="Sao Paolo")
municipality1 = Municipality(name="Brasillia", parent=state)
municipality2 = Municipality(name="Brasil", parent=state)
user_group = Group(name="state_official")
user = User()
user.group = user_group
user.location = state
ona_user = OnaUser(username="******",
user=user,
refresh_token="1239khyackas")
ona_user.save()
reporting_period = ReportingPeriod(
title='Period 1',
start_date=datetime.datetime(2015, 5, 1),
end_date=datetime.datetime(2015, 7, 31))
reporting_period.save()
DBSession.add_all([state, municipality1, municipality2])
def setUp(self):
super(TestStateViews, self).setUp()
self.request = testing.DummyRequest()
self._create_user('state-official')
with transaction.manager:
reporting_period = ReportingPeriod(
title='Period 1',
start_date=datetime.datetime(2015, 5, 1),
end_date=datetime.datetime(2015, 7, 31))
reporting_period.save()
state = State(name="Sao Paolo")
municipality1 = Municipality(name="Brasillia", parent=state)
municipality2 = Municipality(name="Brasil", parent=state)
DBSession.add_all([state, municipality1, municipality2])
for i in range(5):
clinic = Clinic(name="Clinic {}".format(i),
code="{}BCDE".format(i),
municipality=municipality1)
DBSession.add(clinic)
self.request.user = OnaUser.get(
OnaUser.username == 'state-official').user
self.view = StateViews(self.request)
def setup_reporting_periods(self):
self.reporting_period1 = ReportingPeriod(
title="test 1",
form_xpath="jan_2015feb_2015",
start_date=datetime.date(2015, 1, 1),
end_date=datetime.date(2015, 2, 1))
self.reporting_period2 = ReportingPeriod(
title="test 2",
form_xpath="feb_2015mar_2015",
start_date=datetime.date(2015, 2, 1),
end_date=datetime.date(2015, 3, 1))
self.reporting_period3 = ReportingPeriod(
title="test 3",
form_xpath="apr_2015may_2015",
start_date=datetime.date(2015, 4, 1),
end_date=datetime.date(2015, 5, 1))
self.reporting_period_v3 = ReportingPeriod(
title="test 4",
form_xpath="2017",
start_date=datetime.date(2017, 1, 1),
end_date=datetime.date(2017, 12, 31))
DBSession.add_all([self.reporting_period1,
self.reporting_period2,
self.reporting_period3,
self.reporting_period_v3])
def test_get_active_characteristics_filters_by_period(self):
self.setup_test_data()
period_1 = ReportingPeriod.get(ReportingPeriod.title == 'Period 1')
clinic_a = Clinic.get(Clinic.name == 'Clinic A')
period2 = ReportingPeriod(
title='Period 2',
start_date=datetime.datetime(2014, 1, 1),
end_date=datetime.datetime(2014, 1, 1))
DBSession.add(period2)
DBSession.flush()
clinic_char1 = ClinicCharacteristics(
clinic_id=clinic_a.id,
characteristic_id='one',
period_id=period_1.id)
clinic_char2 = ClinicCharacteristics(
clinic_id=clinic_a.id,
characteristic_id='one',
period_id=period2.id)
DBSession.add_all([clinic_char1, clinic_char2])
characteristics = clinic_a.get_active_characteristics(period_1)
self.assertEqual(len(characteristics), 1)
def setUp(self):
super(TestMunicipalityViews, self).setUp()
self.request = testing.DummyRequest()
self._create_user('municipality-manager')
with transaction.manager:
reporting_period = ReportingPeriod(
title='Period 1',
start_date=datetime.datetime(2015, 5, 1),
end_date=datetime.datetime(2015, 7, 31))
reporting_period.save()
municipality = Municipality(name="Brasillia")
DBSession.add(municipality)
for i in range(5):
clinic = Clinic(name="Clinic {}".format(i),
code="{}BCDE".format(i),
municipality=municipality)
DBSession.add(clinic)
self.request.user = OnaUser.get(
OnaUser.username == 'municipality-manager').user
self.view = MunicipalityViews(self.request)
def get_period_from_request(request):
try:
period = ReportingPeriod.get(
ReportingPeriod.id == request.GET.get('period', 0))
except NoResultFound:
period = ReportingPeriod.get_current_period()
return period
def test_get_item_returns_reporting_period(self):
self.setup_test_data()
period = ReportingPeriod(title="2013/2014",
start_date=datetime.datetime(2013, 3, 13),
end_date=datetime.datetime(2014, 3, 13))
DBSession.add(period)
DBSession.flush()
period = ReportingPeriod.newest()
user = User.newest()
selected_period = user.__getitem__(period.id)
self.assertIsInstance(selected_period, ReportingPeriod)
self.assertEqual(selected_period, period)
def show(self):
period = self.request.context
clinic = period.__parent__
# if clinic is not assigned, throw a bad request
# if not clinic.is_assigned:
# raise HTTPBadRequest("The clinic is not yet assigned")
scores = clinic.get_scores(period.form_xpath)
return {
'period':
period,
'periods':
ReportingPeriod.get_active_periods(),
'clinic':
clinic,
'characteristics':
tuple_to_dict_list(("id", "description", "number"),
constants.CHARACTERISTICS),
'client_tools':
tuple_to_dict_list(("id", "name"), constants.CLIENT_TOOLS),
'recommended_sample_frame':
constants.RECOMMENDED_SAMPLE_FRAMES,
'key_indicators':
constants.KEY_INDICATORS,
'scores':
scores
}
def assess_clinics(self):
user = self.request.user
clinics = []
if user.location:
clinics = user.location.clinics
period = get_period_from_request(self.request)
sample_frames = {}
client_tools = {}
_dict = {
'2017':
(constants.RECOMMENDED_SAMPLE_FRAMES, constants.CLIENT_TOOLS)
}
sample_frames, client_tools_cont = _dict.get(
period.form_xpath, (constants.RECOMMENDED_SAMPLE_FRAMES_V2,
constants.CLIENT_TOOLS_V2))
client_tools = tuple_to_dict_list(("id", "name"), client_tools_cont)
return {
'clinics': clinics,
'period': period,
'periods': ReportingPeriod.get_active_periods(),
'client_tools': client_tools,
'recommended_sample_frame': sample_frames,
}
def test_clinic_report_is_generated_if_none_existent_v3(self):
count = ClinicReport.count()
clinic = Clinic.get(Clinic.id == 4)
period = ReportingPeriod.get(ReportingPeriod.title == 'Period 2017')
ClinicReport.get_or_generate(clinic, period)
self.assertEqual(ClinicReport.count(), count + 1)
def test_clinic_show_allows_owner(self):
period = ReportingPeriod.get(ReportingPeriod.title == 'Period 1')
clinic = Clinic.get(Clinic.name == "Clinic A")
url = self.request.route_path('clinics',
traverse=(clinic.id, period.id))
headers = self._login_user('manager_a')
response = self.testapp.get(url, headers=headers)
self.assertEqual(response.status_code, 200)
def test_get_period_submissions(self):
self.setup_test_data()
self.create_submissions()
clinic = Clinic.get(Clinic.name == 'Clinic A')
period = ReportingPeriod.get(ReportingPeriod.title == "Period 1")
submissions = clinic.get_period_clinic_submissions(period.form_xpath)
self.assertEqual(len(submissions), 50)
def test_characteristics_returns_200(self):
clinic = Clinic.get(Clinic.name == "Clinic A")
period = ReportingPeriod.get(ReportingPeriod.title == 'Period 1')
url = self.request.route_path('clinics',
traverse=(clinic.id, period.id,
'characteristics'))
headers = self._login_user('super')
response = self.testapp.get(url, headers=headers)
self.assertEqual(response.status_code, 200)
def push_report_periods(request):
header = ['reporting_period']
rows = []
reporting_periods = ReportingPeriod.get_active_periods()
[rows.append([period.form_xpath]) for period in reporting_periods]
return {'header': header, 'rows': rows}
def test_render_unauthorized_when_forbidden_and_authenticated(self):
# TODO: move setup_test_data call to setUp
self.setup_test_data()
self._create_user('john')
clinic = Clinic.get(Clinic.name == "Clinic A")
period = ReportingPeriod.get(ReportingPeriod.title == "Period 1")
url = self.request.route_url('clinics',
traverse=(clinic.id, period.id))
headers = self._login_user('john')
response = self.testapp.get(url, headers=headers, status=403)
self.assertEqual(response.status_code, 403)
def __getitem__(self, item):
# retrieve the reporting period
try:
period_id = int(item)
period = ReportingPeriod.get(ReportingPeriod.id == period_id)
except (ValueError, NoResultFound):
raise KeyError
else:
period.__parent__ = self
period.__name__ = item
return period
def test_national_official_can_view_clinics(self):
self._create_dash_user("national", "national", "*****@*****.**",
groups.NATIONAL_OFFICIAL)
user = User.newest()
period = ReportingPeriod.get(ReportingPeriod.title == 'Period 1')
clinic = Clinic.get(Clinic.name == "Clinic A")
url = self.request.route_path('clinics',
traverse=(clinic.id, period.id))
headers = self._login_dashboard_user(user)
response = self.testapp.get(url, headers=headers)
self.assertEqual(response.status_code, 200)
def setup_default_reporting_period():
title = 'Dev Period'
params = {
"title": title,
"start_date": datetime.datetime(2014, 11, 5),
"end_date": datetime.datetime(2014, 11, 30)
}
reporting_period = ReportingPeriod.get_or_create(
ReportingPeriod.title == title,
**params)
reporting_period.save()
def test_show(self):
period = ReportingPeriod.get(ReportingPeriod.title == 'Period 1')
clinic = Clinic.get(Clinic.id == 1)
period.__parent__ = clinic
self.request.context = period
response = self.clinic_views.show()
self.assertIsInstance(response['clinic'], Clinic)
self.assertEqual(response['clinic'].id, clinic.id)
self.assertIn('client_tools', response)
self.assertEqual(
response['characteristics'],
tuple_to_dict_list(("id", "description", "number"),
constants.CHARACTERISTICS))
def test_get_item_retrieves_by_id(self):
period = ReportingPeriod(title="2014/2015",
start_date=datetime.date(2014, 2, 1),
end_date=datetime.date(2015, 2, 1))
DBSession.add(period)
DBSession.flush()
id = period.id
factory = ReportingPeriodFactory(testing.DummyRequest())
period = factory.__getitem__(id)
self.assertEqual(period.id, id)
self.assertEqual(period.__parent__, factory)
self.assertEqual(period.__name__, id)
def create(self):
form = Form(ReportingPeriodForm().bind(),
buttons=('Save', ),
css_class='form-horizontal')
if self.request.method == "POST":
post = self.request.POST.items()
try:
payload = form.validate(post)
except ValidationFailure:
pass
else:
if payload['form_xpath'] not in ALLOWED_XPATHS and \
valid_year(payload['form_xpath']) is None:
self.request.session.flash(
_(u"Only numeric values 1-5 and calendar "
"years (YYYY) allowed For Form Xpath"), 'error')
elif DBSession.query(ReportingPeriod).filter_by(
form_xpath=payload['form_xpath']).first():
self.request.session.flash(_(u"Form Xpath Exists"),
'error')
else:
period = ReportingPeriod(title=payload['title'],
form_xpath=payload['form_xpath'],
start_date=payload['start_date'],
end_date=payload['end_date'])
DBSession.add(period)
DBSession.flush()
self.request.session.flash(_(u"Reporting period created"),
'success')
return HTTPFound(
self.request.route_url('periods', traverse=('list')))
# render form
return {'form': form, 'period': ReportingPeriod.get_current_period()}
def test_select_characteristics(self):
period = ReportingPeriod.get(ReportingPeriod.title == 'Period 1')
clinic = Clinic.get(Clinic.id == 1)
period.__parent__ = clinic
self.request.context = period
params = MultiDict([('characteristic_id', 'one'),
('characteristic_id', 'two'),
('characteristic_id', 'three')])
self.request.POST = params
response = self.clinic_views.select_characteristics()
self.assertIsInstance(response, HTTPFound)
self.assertEqual(
response.location,
self.request.route_url('clinics', traverse=(clinic.id, period.id)))
def test_characteristics_list_with_characteristic_type_filter(self):
period = ReportingPeriod.get(ReportingPeriod.title == 'Period 1')
clinic = Clinic.get(Clinic.id == 1)
period.__parent__ = clinic
self.request.context = period
params = MultiDict({'char_type': 'equitable'})
self.request.GET = params
response = self.clinic_views.characteristics_list()
self.assertIsInstance(response['period'], ReportingPeriod)
self.assertIsInstance(response['clinic'], Clinic)
self.assertEqual(response['clinic'].id, clinic.id)
self.assertEqual(len(response['characteristics']), 3),
self.assertEqual(response['indicator_labels'],
dict(constants.INDICATOR_LABELS)),
self.assertEqual(response['characteristic_indicator_mapping'],
constants.CHARACTERISTIC_INDICATOR_MAPPING)
def test_characteristics_list(self):
period = ReportingPeriod.get(ReportingPeriod.title == 'Period 1')
clinic = Clinic.get(Clinic.id == 1)
period.__parent__ = clinic
self.request.context = period
response = self.clinic_views.characteristics_list()
self.assertIsInstance(response['period'], ReportingPeriod)
self.assertIsInstance(response['clinic'], Clinic)
self.assertEqual(response['clinic'].id, clinic.id)
self.assertEqual(
response['characteristics'],
tuple_to_dict_list(("id", "description", "number"),
constants.CHARACTERISTICS)),
self.assertEqual(response['indicator_labels'],
dict(constants.INDICATOR_LABELS)),
self.assertEqual(response['characteristic_indicator_mapping'],
constants.CHARACTERISTIC_INDICATOR_MAPPING)
def __init__(self, request):
self.request = request
self.period = get_period_from_request(request)
self.periods = ReportingPeriod.get_active_periods()
self.key_indicators_key_labels = constants.INDICATOR_LABELS
def test_get_active_period_when_month_is_jan(self):
with patch('whoahqa.models.reporting_period.get_current_date') as mock:
mock.return_value = datetime.date(2017, 7, 10)
active_periods = ReportingPeriod.get_active_periods()
self.assertEqual(len(active_periods), 4)
self.assertIn(self.reporting_period_v3, active_periods)
def test_push_report_periods_with_data(self):
reporting_period1 = ReportingPeriod(
title='Period 1',
form_xpath='2017',
start_date=datetime.datetime(2017, 1, 1),
end_date=datetime.datetime(2017, 12, 31))
reporting_period2 = ReportingPeriod(
title='Period 2',
form_xpath='2018',
start_date=datetime.datetime(2018, 1, 1),
end_date=datetime.datetime(2018, 12, 31))
reporting_period3 = ReportingPeriod(
title='Period 3',
form_xpath='2019',
start_date=datetime.datetime(2019, 1, 1),
end_date=datetime.datetime(2019, 12, 31))
reporting_period1.save()
reporting_period2.save()
reporting_period3.save()
response = push_report_periods(self.request)
self.assertEqual(3, len(response['rows']))
self.assertEqual(['2017'], response['rows'][0])
self.assertEqual(['2018'], response['rows'][1])
self.assertEqual(['2019'], response['rows'][2])
def select_reporting_period(self):
user = self.request.context
periods = ReportingPeriod.all()
url_target = self.request.GET.get('came_from')
return {'periods': periods, 'user': user, 'url_target': url_target}
def list(self):
# This lists all periods including those in the future
periods = ReportingPeriod.all()
return {'periods': periods, 'period': self.period}
def create_clinic_report_v3(self):
clinic = Clinic.get(Clinic.id == 4)
period = ReportingPeriod.get(ReportingPeriod.title == 'Period 2017')
with transaction.manager:
ClinicReport.get_or_generate(clinic, period)
