def test_newest_returns_newest_record_by_id_desc(self):
user1 = User(id=1)
user2 = User(id=2)
with transaction.manager:
DBSession.add_all([user1, user2])
user = User.newest()
self.assertEqual(user.id, 2)
def register(self):
form = Form(RegistrationForm().bind(request=self.request),
buttons=('Save', ))
if self.request.method == 'POST':
data = self.request.POST.items()
try:
values = form.validate(data)
except ValidationFailure:
self.request.session.flash(
_(u"Please fix the highlighted errors below"), "error")
else:
try:
new_user = User()
new_user.update(values)
self.request.session.flash(
_(u"Success! {} user created".format(
new_user.profile.username)), 'success')
return HTTPFound(
self.request.route_url('admin',
traverse=(new_user.id, 'edit')))
except IntegrityError:
transaction.abort()
self.request.session.flash(_("Username already in use"),
"error")
return {'form': form, 'period': get_period_from_request(self.request)}
def main(argv=sys.argv):
if len(argv) != 5:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
pwd_context.load_path(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
username = argv[2]
password = argv[3]
group = argv[4]
with transaction.manager:
group_criteria = Group.name == group
group_params = {'name': group}
group = Group.get_or_create(
group_criteria,
**group_params)
user = User()
user.group = group
profile = UserProfile(
user=user, username=username, password=password)
ona_user_params = {
'user': user,
'username': username,
'refresh_token': 'test'}
ona_user = OnaUser.get_or_create(
OnaUser.username == username,
**ona_user_params)
DBSession.add_all([user, profile, ona_user])
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_users():
group_criteria = Group.name == groups.SUPER_USER
group_params = {'name': groups.SUPER_USER}
su_group = Group.get_or_create(
group_criteria,
**group_params)
su = User()
user_profile_criteria = UserProfile.username == 'admin'
user_profile_params = {
'user': su,
'username': '******',
'password': '******'}
profile = UserProfile.get_or_create(
user_profile_criteria,
**user_profile_params)
ona_user_params = {
'user': su,
'username': '******',
'refresh_token': '123456'}
ona_user = OnaUser.get_or_create(
OnaUser.username == "admin",
**ona_user_params)
su.group = su_group
profile.save()
ona_user.save()
def test_get_item_returns_user_if_id_exists(self):
self.setup_test_data()
user = User.newest()
request = testing.DummyRequest()
user = UserFactory(request).__getitem__(user.id)
self.assertIsInstance(user, User)
def test_password_login_with_bad_password(self):
profile = UserProfile(user=User(), username="******", password="******")
DBSession.add(profile)
payload = MultiDict([('username', 'admin'), ('password', 'adminn0t')])
request = testing.DummyRequest(post=payload)
response = password_login(None, request)
self.assertIsInstance(response, dict)
self.assertTrue(len(request.session.peek_flash('error')) > 0)
def test_create_clinic_from_submission(self):
# create user with matching id
DBSession.add(User())
user = User.newest()
payload = self.clinic_registrations[0]
raw_data = json.loads(payload)
raw_data[constants.USER_ID] = user.id
submission = Submission(raw_data=raw_data)
count = Clinic.count()
ClinicRegistrationHandler(submission).handle_submission()
# check that a clinic_submission record was created
self.assertEqual(Clinic.count(), count + 1)
clinic = Clinic.newest()
self.assertEqual(clinic.code, '1A2B')
def test_password_login(self):
# create the user profile
profile = UserProfile(user=User(), username="******", password="******")
DBSession.add(profile)
payload = MultiDict([('username', 'admin'), ('password', 'admin')])
request = testing.DummyRequest(post=payload)
response = password_login(None, request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.location, request.route_url('default'))
def test_can_register_new_clinic_users(self):
ona_user = OnaUser.get(OnaUser.username == 'manager_a')
user = ona_user.user
old_user_count = User.count()
self.request.context = user
self.request.method = 'POST'
params = MultiDict({'email': "*****@*****.**",
'username': "******",
'password': {'password': '******',
'password-confirm': 'password'},
'group': groups.CLINIC_MANAGER,
'clinics': ['1']})
self.request.POST = params
response = self.view.register()
self.assertEqual(User.count(), old_user_count + 1)
self.assertEqual(response.status_code, 302)
def test_dashboard_user_logout(self):
dashboard_user = UserProfile(user=User(),
username="******",
password="******")
request = testing.DummyRequest()
request.context = dashboard_user.user
request.user = dashboard_user.user
response = logout(request)
self.assertIsInstance(response, HTTPFound)
self.assertEqual(response.location,
request.route_url('auth', action='sign-in'))
def test_can_register_new_state_users(self):
self._create_state()
ona_user = OnaUser.get(OnaUser.username == 'manager_a')
user = ona_user.user
old_user_count = User.count()
state = State.newest()
self.request.context = user
self.request.method = 'POST'
params = MultiDict({'email': "*****@*****.**",
'username': "******",
'password': {'password': '******',
'password-confirm': 'password'},
'group': groups.STATE_OFFICIAL,
'state': "{}".format(state.id)})
self.request.POST = params
response = self.view.register()
self.assertEqual(User.count(), old_user_count + 1)
self.assertEqual(response.status_code, 302)
def test_can_register_new_municipality_users(self):
self._create_municipality()
ona_user = OnaUser.get(OnaUser.username == 'manager_a')
user = ona_user.user
old_user_count = User.count()
municipality = Municipality.newest()
self.request.context = user
self.request.method = 'POST'
params = MultiDict({'email': "*****@*****.**",
'username': "******",
'password': {'password': '******',
'password-confirm': 'password'},
'group': groups.MUNICIPALITY_MANAGER,
'municipality': "{}".format(municipality.id)})
self.request.POST = params
response = self.view.register()
self.assertEqual(User.count(), old_user_count + 1)
self.assertEqual(response.status_code, 302)
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 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 main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
user = User()
DBSession.add_all([user])
def test_national_official_can_list_states(self):
self._create_dash_user("national", "national", "*****@*****.**",
groups.NATIONAL_OFFICIAL)
user = User.newest()
url = self.request.route_path('states', traverse=())
headers = self._login_dashboard_user(user)
with patch('whoahqa.models.reporting_period.get_current_date') as mock:
mock.return_value = datetime.date(2015, 6, 1)
response = self.testapp.get(url, headers=headers)
self.assertEqual(response.status_code, 200)
def test_add_clinics_to_user(self):
self.setup_test_data()
user = User()
ona_user = OnaUser(
user=user, username='******', refresh_token="c563e9")
values = {'group': groups.CLINIC_MANAGER,
'clinics': ["1", "2", "3"]}
ona_user.update(values)
self.assertEqual(len(ona_user.user.clinics), 3)
def test_update_new_user_group(self):
user = User()
ona_user = OnaUser(
user=user, username='******', refresh_token="c563e9")
self._create_municipality('Brazlandia')
municipality = Municipality.get(Municipality.name == 'Brazlandia')
values = {'group': groups.MUNICIPALITY_MANAGER,
'municipality': municipality.id}
ona_user.update(values)
self.assertEqual(ona_user.user.group.name, groups.MUNICIPALITY_MANAGER)
self.assertEqual(ona_user.user.location, municipality)
def group_finder(userid, request):
from whoahqa.models import User
principals = []
principals.append("u:{}".format(userid))
try:
user = User.get(User.id == userid)
except NoResultFound:
return None
else:
if user.group:
principals.append(user.group.name)
principals.extend(GROUP_PERMISSIONS.get(user.group.name, []))
return principals
def test_redirects_to_states_for_national_official(self):
self.setup_test_data()
self._create_dash_user("national", "national", "*****@*****.**",
groups.NATIONAL_OFFICIAL)
user = User.newest()
url = self.request.route_url('default')
headers = self._login_dashboard_user(user)
response = self.testapp.get(url, headers=headers)
period = get_period_from_request(self.request)
self.assertEqual(response.status_code, 302)
self.assertEqual(
self.request.route_url('states',
traverse=(),
_query={'period': period.id}),
response.location)
def handle_submission(self):
from whoahqa.models import User
map_data = ClinicRegistrationHandler.parse_data(
self.submission.raw_data)
clinic = Clinic(name=map_data['clinic_name'],
code=map_data['clinic_code'])
# check is user exists
user = None
try:
user = User.get(User.id == map_data['user_id'])
except NoResultFound:
pass
else:
clinic.user = user
finally:
clinic.save()
# if no user, raise UserNotFound
if user is None:
raise UserNotFound("User with id {} was not found".format(
map_data['user_id']))
def test_password_property_returns_raw_password(self):
profile = UserProfile(user=User(), username="******", password="******")
self.assertEqual(profile.password, profile.pwd)
def test_check_password_returns_false_if_len_greater_than_255(self):
profile = UserProfile(user=User(), username="******", password="******")
self.assertFalse(profile.check_password('a' * 256))
def test_check_password(self):
profile = UserProfile(user=User(), username="******", password="******")
self.assertTrue(profile.check_password('admin'))
def test_set_password(self):
profile = UserProfile(user=User(), username="******", password="******")
self.assertTrue(pwd_context.verify('admin', profile.pwd))
def list(self):
users = User.all()
period = get_period_from_request(self.request)
return {'users': users, 'period': period}
def test_get_returns_record_filtered_by_criterion(self):
user = User(id=1)
with transaction.manager:
DBSession.add(user)
user = User.get(User.id == 1)
self.assertIsInstance(user, User)
def get_request_user(request):
user_id = request.authenticated_userid
try:
return User.get(User.id == user_id)
except NoResultFound:
return None
def test_raise_key_error_when_invalid_period_id(self):
self.setup_test_data()
user = User.newest()
self.assertRaises(KeyError, user.__getitem__, "abc")
