def setUp(self):
"""
Sets up the testing environment;
creates a `UserController`
"""
self.init(user_role=model.ROLE_ADMINISTRATOR)
self.user_c = UserController()
def transactional_setup_method(self):
"""
Sets up the testing environment;
creates a `UserController`
"""
self.init(user_role=ROLE_ADMINISTRATOR)
self.user_c = UserController()
def setUp(self):
"""
Sets up the testing environment;
creates a `UserController`
"""
self.init(user_role=model.ROLE_ADMINISTRATOR)
self.user_c = UserController()
def transactional_setup_method(self):
"""
Sets up the testing environment;
creates a `UserController`
"""
self.init(user_role=model.ROLE_ADMINISTRATOR)
self.user_c = UserController()
def init_cherrypy(arguments=None):
#### Mount static folders from modules marked for introspection
arguments = arguments or []
CONFIGUER = TvbProfile.current.web.CHERRYPY_CONFIGURATION
for module in arguments:
module_inst = importlib.import_module(str(module))
module_path = os.path.dirname(os.path.abspath(module_inst.__file__))
CONFIGUER["/static_" + str(module)] = {'tools.staticdir.on': True,
'tools.staticdir.dir': '.',
'tools.staticdir.root': module_path}
#### Mount controllers, and specify the root URL for them.
cherrypy.tree.mount(BaseController(), "/", config=CONFIGUER)
cherrypy.tree.mount(UserController(), "/user/", config=CONFIGUER)
cherrypy.tree.mount(ProjectController(), "/project/", config=CONFIGUER)
cherrypy.tree.mount(FigureController(), "/project/figure/", config=CONFIGUER)
cherrypy.tree.mount(FlowController(), "/flow/", config=CONFIGUER)
cherrypy.tree.mount(SettingsController(), "/settings/", config=CONFIGUER)
cherrypy.tree.mount(HelpController(), "/help/", config=CONFIGUER)
cherrypy.tree.mount(SimulatorController(), "/burst/", config=CONFIGUER)
cherrypy.tree.mount(ParameterExplorationController(), "/burst/explore/", config=CONFIGUER)
cherrypy.tree.mount(DynamicModelController(), "/burst/dynamic/", config=CONFIGUER)
cherrypy.tree.mount(SpatioTemporalController(), "/spatial/", config=CONFIGUER)
cherrypy.tree.mount(RegionsModelParametersController(), "/burst/modelparameters/regions/", config=CONFIGUER)
cherrypy.tree.mount(SurfaceModelParametersController(), "/spatial/modelparameters/surface/", config=CONFIGUER)
cherrypy.tree.mount(RegionStimulusController(), "/spatial/stimulus/region/", config=CONFIGUER)
cherrypy.tree.mount(SurfaceStimulusController(), "/spatial/stimulus/surface/", config=CONFIGUER)
cherrypy.tree.mount(LocalConnectivityController(), "/spatial/localconnectivity/", config=CONFIGUER)
cherrypy.tree.mount(NoiseConfigurationController(), "/burst/noise/", config=CONFIGUER)
cherrypy.tree.mount(HPCController(), "/hpc/", config=CONFIGUER)
cherrypy.config.update(CONFIGUER)
# ----------------- Register additional request handlers -----------------
# This tool checks for MAX upload size
cherrypy.tools.upload = Tool('on_start_resource', RequestHandler.check_upload_size)
# This tools clean up files on disk (mainly after export)
cherrypy.tools.cleanup = Tool('on_end_request', RequestHandler.clean_files_on_disk)
# ----------------- End register additional request handlers ----------------
# Register housekeeping job
if TvbProfile.current.hpc.IS_HPC_RUN and TvbProfile.current.hpc.CAN_RUN_HPC:
cherrypy.engine.housekeeper = cherrypy.process.plugins.BackgroundTask(
TvbProfile.current.hpc.BACKGROUND_JOB_INTERVAL, HPCOperationService.check_operations_job)
cherrypy.engine.housekeeper.start()
# HTTP Server is fired now ######
cherrypy.engine.start()
def __init__(self):
UserController.__init__(self)
self.settingsservice = SettingsService()
class UsersControllerTest(BaseTransactionalControllerTest):
"""Unit test for UserController"""
def setUp(self):
"""
Sets up the testing environment;
creates a `UserController`
"""
self.init(user_role=model.ROLE_ADMINISTRATOR)
self.user_c = UserController()
def tearDown(self):
""" Cleans the testing environment """
self.cleanup()
def test_index_valid_post(self):
"""
Tests for a valid redirect on user login
"""
user = model.User('valid_user', md5('valid_pass').hexdigest(), '*****@*****.**', True, 'CLINICIAN')
dao.store_entity(user)
login_data = {'username': '******', 'password': '******'}
cherrypy.request.method = "POST"
self._expect_redirect('/user/profile', self.user_c.index, **login_data)
def test_profile_logout(self):
"""
Simulate a logout and make sure we are redirected to the logout page.
"""
cherrypy.request.method = "POST"
self._expect_redirect('/user/logout', self.user_c.profile, logout=True)
def test_profile_no_settings(self):
"""
Delete the dummy tvb settings file and make sure we are redirected to the settings page.
"""
os.remove(TvbProfile.current.TVB_CONFIG_FILE)
TvbProfile.current.manager.stored_settings = None
self._expect_redirect('/settings/settings', self.user_c.profile)
def test_profile_get(self):
"""
Simulate a GET request and make sure all required information for the user profile
page are returned.
"""
cherrypy.request.method = "GET"
template_dict = self.user_c.profile()
self._check_default_attributes(template_dict, {}, {})
self.assertEqual(template_dict[common.KEY_USER].id, self.test_user.id)
def test_profile_edit(self):
"""
Simulate a edit of the email and check that data is actually changed.
"""
edited_data = {'email': u'*****@*****.**'}
cherrypy.request.method = "POST"
self.user_c.profile(save=True, **edited_data)
user = dao.get_user_by_id(self.test_user.id)
self.assertEqual('*****@*****.**', user.email)
def test_logout(self):
"""
Test that a logout removes the user from session.
"""
cherrypy.request.config = {'tools.sessions.name': 'session_id'}
cherrypy.serving.response.cookie['session_id'] = 1
self._expect_redirect('/user', self.user_c.logout)
self.assertTrue(common.KEY_USER not in cherrypy.session, "User should be removed after logout.")
def test_switch_online_help(self):
"""
Test the switchOnlineHelp method and make sure it adds corresponding entry to UserPreferences.
"""
self._expect_redirect('/user/profile', self.user_c.switchOnlineHelp)
self.assertFalse(utils.string2bool(self.test_user.preferences[UserPreferences.ONLINE_HELP_ACTIVE]),
"Online help should be switched to False.")
def test_register_cancel(self):
"""
Test cancel on registration page.
"""
self._expect_redirect('/user', self.user_c.register, cancel=True)
def test_register_post_valid(self):
"""
Test with valid data and check user is created.
"""
cherrypy.request.method = "POST"
data = dict(username="******",
password="******",
password2="pass",
email="*****@*****.**",
comment="This is some dummy comment",
role="CLINICIAN")
self._expect_redirect('/user', self.user_c.register, **data)
stored_user = dao.get_user_by_name('registered_user')
self.assertTrue(stored_user is not None, "New user should be saved.")
def test_register_post_invalid_data(self):
"""
Check that errors field from template is filled in case invalid data is submitted.
"""
cherrypy.request.method = "POST"
# Data invalid missing username
data = dict(password="******",
password2="pass",
email="*****@*****.**",
comment="This is some dummy comment",
role="CLINICIAN")
template_dict = self.user_c.register(**data)
self.assertTrue(template_dict[common.KEY_ERRORS] != {}, "Errors should contain some data.")
def test_create_new_cancel(self):
"""
Test that a cancel brings you back to usermanagement.
"""
self._expect_redirect('/user/usermanagement', self.user_c.create_new, cancel=True)
def test_create_new_valid_post(self):
"""
Test that a valid create new post will actually create a new user in database.
"""
data = dict(username="******",
password="******",
password2="pass",
email="*****@*****.**",
comment="This is some dummy comment",
role="CLINICIAN")
cherrypy.request.method = "POST"
self._expect_redirect('/user/usermanagement', self.user_c.create_new, **data)
created_user = dao.get_user_by_name("registered_user")
self.assertTrue(created_user is not None, "Should have a new user created.")
def test_usermanagement_no_access(self):
"""
Since we need to be admin to access this, we should get redirect to /tvb.
"""
self.test_user.role = "TEST"
self._expect_redirect('/tvb', self.user_c.usermanagement)
self.assertEqual(cherrypy.session[common.KEY_MESSAGE_TYPE], common.TYPE_ERROR)
def test_usermanagement_cancel(self):
"""
Test that a cancel redirects us to a corresponding page.
"""
self.test_user.role = "ADMINISTRATOR"
self.test_user = dao.store_entity(self.test_user)
cherrypy.session[common.KEY_USER] = self.test_user
self._expect_redirect('/user/profile', self.user_c.usermanagement, cancel=True)
def test_usermanagement_post_valid(self):
"""
Create a valid post and check that user is created.
"""
self.test_user.role = "ADMINISTRATOR"
self.test_user = dao.store_entity(self.test_user)
cherrypy.session[common.KEY_USER] = self.test_user
TestFactory.create_user(username="******")
TestFactory.create_user(username="******", validated=False)
user_before_delete = dao.get_user_by_name("to_be_deleted")
self.assertTrue(user_before_delete is not None)
user_before_validation = dao.get_user_by_name("to_validate")
self.assertFalse(user_before_validation.validated)
data = {"delete_%i" % user_before_delete.id: True,
"role_%i" % user_before_validation.id: "ADMINISTRATOR",
"validate_%i" % user_before_validation.id: True}
self.user_c.usermanagement(do_persist=True, **data)
user_after_delete = dao.get_user_by_id(user_before_delete.id)
self.assertTrue(user_after_delete is None, "User should be deleted.")
user_after_validation = dao.get_user_by_id(user_before_validation.id)
self.assertTrue(user_after_validation.validated, "User should be validated now.")
self.assertTrue(user_after_validation.role == "ADMINISTRATOR", "Role has not changed.")
def test_recoverpassword_cancel(self):
"""
Test that cancel redirects to user page.
"""
cherrypy.request.method = "POST"
self._expect_redirect('/user', self.user_c.recoverpassword, cancel=True)
def test_recoverpassword_valid_post(self):
"""
Test a valid password recovery.
"""
cherrypy.request.method = "POST"
data = {"email": self.test_user.email,
"username": ""}
self._expect_redirect("/user", self.user_c.recoverpassword, **data)
self.assertTrue(cherrypy.session[common.KEY_MESSAGE_TYPE] == common.TYPE_INFO,
"Info message informing successfull reset should be present")
def test_validate_valid(self):
"""
Pass a valid user and test that it is actually validate.
"""
self.test_user.role = "ADMINISTRATOR"
self.test_user = dao.store_entity(self.test_user)
cherrypy.session[common.KEY_USER] = self.test_user
TestFactory.create_user(username="******", validated=False)
user_before_validation = dao.get_user_by_name("to_validate")
self.assertFalse(user_before_validation.validated)
self._expect_redirect('/tvb', self.user_c.validate, user_before_validation.username)
user_after_validation = dao.get_user_by_id(user_before_validation.id)
self.assertTrue(user_after_validation.validated, "User should be validated.")
self.assertTrue(cherrypy.session[common.KEY_MESSAGE_TYPE] == common.TYPE_INFO)
def test_validate_invalid(self):
"""
Pass a valid user and test that it is actually validate.
"""
unexisting = dao.get_user_by_name("should-not-exist")
self.assertTrue(unexisting is None, "This user should not exist")
self._expect_redirect('/tvb', self.user_c.validate, "should-not-exist")
self.assertTrue(cherrypy.session[common.KEY_MESSAGE_TYPE] == common.TYPE_ERROR)
def _check_default_attributes(self, template_dict, data, errors):
"""
Check that all the defaults are present in the template dictionary.
"""
self.assertEqual(template_dict[common.KEY_LINK_ANALYZE], '/flow/step/2')
self.assertEqual(template_dict[common.KEY_BACK_PAGE], False)
self.assertEqual(template_dict[common.KEY_LINK_CONNECTIVITY_TAB], '/flow/step_connectivity')
self.assertEqual(template_dict[common.KEY_CURRENT_TAB], 'nav-user')
self.assertEqual(template_dict[common.KEY_FORM_DATA], data)
self.assertEqual(template_dict[common.KEY_ERRORS], errors)
self.assertEqual(template_dict[common.KEY_INCLUDE_TOOLTIP], True)
def __init__(self):
UserController.__init__(self)
self.settingsservice = SettingsService()
class TestUsersController(BaseTransactionalControllerTest):
"""Unit test for UserController"""
def transactional_setup_method(self):
"""
Sets up the testing environment;
creates a `UserController`
"""
self.clean_database()
self.init(user_role=ROLE_ADMINISTRATOR)
self.user_c = UserController()
def transactional_teardown_method(self):
""" Cleans the testing environment """
self.cleanup()
self.clean_database()
def test_index_valid_post(self):
"""
Tests for a valid redirect on user login
"""
user = User('valid_user', 'name', hash_password('valid_pass'), '*****@*****.**', True, 'CLINICIAN')
dao.store_entity(user)
login_data = {'username': '******', 'password': '******'}
cherrypy.request.method = "POST"
self._expect_redirect('/user/profile', self.user_c.index, **login_data)
def test_profile_logout(self):
"""
Simulate a logout and make sure we are redirected to the logout page.
"""
cherrypy.request.method = "POST"
self._expect_redirect('/user/logout', self.user_c.profile, logout=True)
def test_profile_no_settings(self):
"""
Delete the dummy tvb settings file and make sure we are redirected to the settings page.
"""
os.remove(TvbProfile.current.TVB_CONFIG_FILE)
TvbProfile.current.manager.stored_settings = None
self._expect_redirect('/settings/settings', self.user_c.profile)
def test_profile_get(self):
"""
Simulate a GET request and make sure all required information for the user profile
page are returned.
"""
cherrypy.request.method = "GET"
template_dict = self.user_c.profile()
self._check_default_attributes(template_dict, {}, {})
assert template_dict[common.KEY_USER].id == self.test_user.id
def test_profile_edit(self):
"""
Simulate a edit of the email and check that data is actually changed.
"""
edited_data = {'email': '*****@*****.**'}
cherrypy.request.method = "POST"
self.user_c.profile(save=True, **edited_data)
user = dao.get_user_by_id(self.test_user.id)
assert '*****@*****.**' == user.email
def test_logout(self):
"""
Test that a logout removes the user from session.
"""
cherrypy.request.config = {'tools.sessions.name': 'session_id'}
cherrypy.serving.response.cookie['session_id'] = 1
self._expect_redirect('/user', self.user_c.logout)
assert common.KEY_USER not in cherrypy.session, "User should be removed after logout."
def test_switch_online_help(self):
"""
Test the switch_online_help method and make sure it adds corresponding entry to UserPreferences.
"""
self._expect_redirect('/user/profile', self.user_c.switch_online_help)
assert not string2bool(self.test_user.preferences[UserPreferences.ONLINE_HELP_ACTIVE]), \
"Online help should be switched to False."
def test_register_cancel(self):
"""
Test cancel on registration page.
"""
self._expect_redirect('/user', self.user_c.register, cancel=True)
def test_register_post_valid(self):
"""
Test with valid data and check user is created.
"""
cherrypy.request.method = "POST"
data = dict(username="******",
display_name="display_name",
password="******",
password2="pass",
email="*****@*****.**",
comment="This is some dummy comment",
role="CLINICIAN")
self._expect_redirect('/user', self.user_c.register, **data)
stored_user = dao.get_user_by_name('registered_user')
assert stored_user is not None, "New user should be saved."
def test_register_post_invalid_data(self):
"""
Check that errors field from template is filled in case invalid data is submitted.
"""
cherrypy.request.method = "POST"
# Data invalid missing username
data = dict(password="******",
password2="pass",
email="*****@*****.**",
comment="This is some dummy comment",
role="CLINICIAN")
template_dict = self.user_c.register(**data)
assert template_dict[common.KEY_ERRORS] != {}, "Errors should contain some data."
def test_create_new_cancel(self):
"""
Test that a cancel brings you back to usermanagement.
"""
self._expect_redirect('/user/usermanagement', self.user_c.create_new, cancel=True)
def test_create_new_valid_post(self):
"""
Test that a valid create new post will actually create a new user in database.
"""
data = dict(username="******",
display_name="display_name",
password="******",
password2="pass",
email="*****@*****.**",
comment="This is some dummy comment",
role="CLINICIAN")
cherrypy.request.method = "POST"
self._expect_redirect('/user/usermanagement', self.user_c.create_new, **data)
created_user = dao.get_user_by_name("registered_user")
assert created_user is not None, "Should have a new user created."
def test_usermanagement_no_access(self):
"""
Since we need to be admin to access this, we should get redirect to /tvb.
"""
self.test_user.role = "TEST"
self._expect_redirect('/tvb', self.user_c.usermanagement)
assert cherrypy.session[common.KEY_MESSAGE_TYPE] == common.TYPE_ERROR
def test_usermanagement_cancel(self):
"""
Test that a cancel redirects us to a corresponding page.
"""
self.test_user.role = "ADMINISTRATOR"
self.test_user = dao.store_entity(self.test_user)
cherrypy.session[common.KEY_USER] = self.test_user
self._expect_redirect('/user/profile', self.user_c.usermanagement, cancel=True)
def test_usermanagement_post_valid(self):
"""
Create a valid post and check that user is created.
"""
self.test_user.role = "ADMINISTRATOR"
self.test_user = dao.store_entity(self.test_user)
cherrypy.session[common.KEY_USER] = self.test_user
TestFactory.create_user(username="******")
TestFactory.create_user(username="******", validated=False)
user_before_delete = dao.get_user_by_name("to_be_deleted")
assert user_before_delete is not None
user_before_validation = dao.get_user_by_name("to_validate")
assert not user_before_validation.validated
data = {"delete_%i" % user_before_delete.id: True,
"role_%i" % user_before_validation.id: "ADMINISTRATOR",
"validate_%i" % user_before_validation.id: True}
self.user_c.usermanagement(do_persist=True, **data)
user_after_delete = dao.get_user_by_id(user_before_delete.id)
assert user_after_delete is None, "User should be deleted."
user_after_validation = dao.get_user_by_id(user_before_validation.id)
assert user_after_validation.validated, "User should be validated now."
assert user_after_validation.role == "ADMINISTRATOR", "Role has not changed."
def test_recoverpassword_cancel(self):
"""
Test that cancel redirects to user page.
"""
cherrypy.request.method = "POST"
self._expect_redirect('/user', self.user_c.recoverpassword, cancel=True)
def test_recoverpassword_valid_post(self):
"""
Test a valid password recovery.
"""
cherrypy.request.method = "POST"
data = {"email": self.test_user.email,
"username": self.test_user.username,
}
self._expect_redirect("/user", self.user_c.recoverpassword, **data)
assert cherrypy.session[common.KEY_MESSAGE_TYPE] == common.TYPE_INFO, \
"Info message informing successfull reset should be present"
def test_validate_valid(self):
"""
Pass a valid user and test that it is actually validate.
"""
self.test_user.role = "ADMINISTRATOR"
self.test_user = dao.store_entity(self.test_user)
cherrypy.session[common.KEY_USER] = self.test_user
TestFactory.create_user(username="******", validated=False)
user_before_validation = dao.get_user_by_name("to_validate")
assert not user_before_validation.validated
self._expect_redirect('/tvb', self.user_c.validate, user_before_validation.username)
user_after_validation = dao.get_user_by_id(user_before_validation.id)
assert user_after_validation.validated, "User should be validated."
assert cherrypy.session[common.KEY_MESSAGE_TYPE] == common.TYPE_INFO
def test_validate_invalid(self):
"""
Pass a valid user and test that it is actually validate.
"""
unexisting = dao.get_user_by_name("should-not-exist")
assert unexisting is None, "This user should not exist"
self._expect_redirect('/tvb', self.user_c.validate, "should-not-exist")
assert cherrypy.session[common.KEY_MESSAGE_TYPE] == common.TYPE_ERROR
def _check_default_attributes(self, template_dict, data, errors):
"""
Check that all the defaults are present in the template dictionary.
"""
assert template_dict[common.KEY_LINK_ANALYZE] == '/flow/step_analyzers'
assert template_dict[common.KEY_BACK_PAGE] == False
assert template_dict[common.KEY_LINK_CONNECTIVITY_TAB] == '/flow/step_connectivity'
assert template_dict[common.KEY_CURRENT_TAB] == 'nav-user'
assert template_dict[common.KEY_FORM_DATA] == data
assert template_dict[common.KEY_ERRORS] == errors
assert template_dict[common.KEY_INCLUDE_TOOLTIP] is True
