def setUp(self):
"""
Sets up the environment for testing
creates a `NoiseConfigurationController`
"""
self.init()
self.noise_c = NoiseConfigurationController()
_, self.connectivity = DatatypesFactory().create_connectivity()
BurstController().index()
stored_burst = cherrypy.session[common.KEY_BURST_CONFIG]
new_params = {}
for key, val in SIMULATOR_PARAMETERS.iteritems():
new_params[key] = {'value': val}
new_params['connectivity'] = {'value': self.connectivity.gid}
# Simulate selection of a specific integration from the ui
new_params[PARAM_INTEGRATOR] = {'value': EulerStochastic.__name__}
new_params[PARAM_MODEL] = {'value': Generic2dOscillator.__name__}
new_params[INTEGRATOR_PARAMETERS + '_option_EulerStochastic_noise'] = {
'value': Additive.__name__
}
stored_burst.simulator_configuration = new_params
self.noise_c.index()
class NoiseConfigurationControllerTest(BaseTransactionalControllerTest):
def setUp(self):
"""
Sets up the environment for testing
creates a `NoiseConfigurationController`
"""
self.init()
self.noise_c = NoiseConfigurationController()
_, self.connectivity = DatatypesFactory().create_connectivity()
BurstController().index()
stored_burst = cherrypy.session[common.KEY_BURST_CONFIG]
new_params = {}
for key, val in SIMULATOR_PARAMETERS.iteritems():
new_params[key] = {'value': val}
new_params['connectivity'] = {'value': self.connectivity.gid}
# Simulate selection of a specific integration from the ui
new_params[PARAM_INTEGRATOR] = {'value': EulerStochastic.__name__}
new_params[PARAM_MODEL] = {'value': Generic2dOscillator.__name__}
new_params[INTEGRATOR_PARAMETERS + '_option_EulerStochastic_noise'] = {
'value': Additive.__name__
}
stored_burst.simulator_configuration = new_params
self.noise_c.index()
def tearDown(self):
""" Cleans the testing environment """
self.cleanup()
def test_submit_noise_configuration_happy(self):
"""
Submit noise configuration writes the noise array on the required key in the burst configuration
"""
# a noise configuration in the format expected by submit. Assumes Generic2dOscillator model.
nodes_range = range(self.connectivity.number_of_regions)
noise_in = [{'V': 1.0, 'W': 2.0} for _ in nodes_range]
noise_in = json.dumps(noise_in)
# expected noise array in burst config
expected_noise_arr = [[1.0 for _ in nodes_range],
[2.0 for _ in nodes_range]]
self._expect_redirect('/burst/', self.noise_c.submit, noise_in)
simulator_configuration = cherrypy.session[
common.KEY_BURST_CONFIG].simulator_configuration
nsig_key = 'integrator_parameters_option_EulerStochastic_noise_parameters_option_Additive_nsig'
actual_noise_arr = json.loads(
simulator_configuration[nsig_key]['value'])
self.assertEquals(expected_noise_arr, actual_noise_arr)
class TestNoiseConfigurationController(BaseTransactionalControllerTest):
def transactional_setup_method(self):
"""
Sets up the environment for testing
creates a `NoiseConfigurationController`
"""
self.init()
self.noise_c = NoiseConfigurationController()
_, self.connectivity = DatatypesFactory().create_connectivity()
BurstController().index()
stored_burst = cherrypy.session[common.KEY_BURST_CONFIG]
new_params = {}
for key, val in SIMULATOR_PARAMETERS.iteritems():
new_params[key] = {'value': val}
new_params['connectivity'] = {'value': self.connectivity.gid}
# Simulate selection of a specific integration from the ui
new_params[PARAM_INTEGRATOR] = {'value': EulerStochastic.__name__}
new_params[PARAM_MODEL] = {'value': Generic2dOscillator.__name__}
new_params[INTEGRATOR_PARAMETERS + '_option_EulerStochastic_noise'] = {'value': Additive.__name__}
stored_burst.simulator_configuration = new_params
self.noise_c.index()
def transactional_teardown_method(self):
""" Cleans the testing environment """
self.cleanup()
def test_submit_noise_configuration_happy(self):
"""
Submit noise configuration writes the noise array on the required key in the burst configuration
"""
# a noise configuration in the format expected by submit. Assumes Generic2dOscillator model.
nodes_range = range(self.connectivity.number_of_regions)
noise_in = [{'V': 1.0, 'W': 2.0} for _ in nodes_range]
noise_in = json.dumps(noise_in)
# expected noise array in burst config
expected_noise_arr = [[1.0 for _ in nodes_range], [2.0 for _ in nodes_range]]
self._expect_redirect('/burst/', self.noise_c.submit, noise_in)
simulator_configuration = cherrypy.session[common.KEY_BURST_CONFIG].simulator_configuration
nsig_key = 'integrator_parameters_option_EulerStochastic_noise_parameters_option_Additive_nsig'
actual_noise_arr = json.loads(simulator_configuration[nsig_key]['value'])
assert expected_noise_arr == actual_noise_arr
def test_submit_noise_configuration_happy(self, connectivity_factory):
"""
Submit noise configuration writes the noise array on the required key in the burst configuration
"""
self.init()
noise_controller = NoiseConfigurationController()
simulator_controller = SimulatorController()
simulator_controller.index()
simulator = simulator_controller.context.simulator
connectivity = connectivity_factory()
simulator.connectivity = connectivity.gid
simulator.integrator = HeunStochasticViewModel()
# a noise configuration in the format expected by submit. Assumes Generic2dOscillator model.
nodes_range = list(range(connectivity.number_of_regions))
noise_in = [{'V': 1.0, 'W': 2.0} for _ in nodes_range]
noise_in = json.dumps(noise_in)
self._expect_redirect('/burst/', noise_controller.submit, noise_in)
expected_noise_arr = [[1.0 for _ in nodes_range],
[2.0 for _ in nodes_range]]
actual_noise_arr = simulator.integrator.noise.nsig
assert (expected_noise_arr == actual_noise_arr).all()
self.cleanup()
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 test_submit_noise_configuration_happy(self, connectivity_factory):
self.init()
self.noise_c = NoiseConfigurationController()
self.connectivity = connectivity_factory()
SimulatorController().index()
stored_burst = cherrypy.session[common.KEY_BURST_CONFIG]
new_params = {}
for key, val in SIMULATOR_PARAMETERS.items():
new_params[key] = {'value': val}
new_params['connectivity'] = {'value': self.connectivity.gid}
# Simulate selection of a specific integration from the ui
new_params[PARAM_INTEGRATOR] = {'value': EulerStochastic.__name__}
new_params[PARAM_MODEL] = {
'value': ModelsEnum.GENERIC_2D_OSCILLATOR.get_class().__name__
}
new_params[INTEGRATOR_PARAMETERS + '_option_EulerStochastic_noise'] = {
'value': Additive.__name__
}
stored_burst.simulator_configuration = new_params
"""
Submit noise configuration writes the noise array on the required key in the burst configuration
"""
# a noise configuration in the format expected by submit. Assumes Generic2dOscillator model.
nodes_range = list(range(self.connectivity.number_of_regions))
noise_in = [{'V': 1.0, 'W': 2.0} for _ in nodes_range]
noise_in = json.dumps(noise_in)
# expected noise array in burst config
expected_noise_arr = [[1.0 for _ in nodes_range],
[2.0 for _ in nodes_range]]
self._expect_redirect('/burst/', self.noise_c.submit, noise_in)
simulator_configuration = cherrypy.session[
common.KEY_BURST_CONFIG].simulator_configuration
nsig_key = 'integrator_parameters_option_EulerStochastic_noise_parameters_option_Additive_nsig'
actual_noise_arr = json.loads(
simulator_configuration[nsig_key]['value'])
assert expected_noise_arr == actual_noise_arr
def transactional_setup_method(self):
"""
Sets up the environment for testing
creates a `NoiseConfigurationController`
"""
self.init()
self.noise_c = NoiseConfigurationController()
_, self.connectivity = DatatypesFactory().create_connectivity()
BurstController().index()
stored_burst = cherrypy.session[common.KEY_BURST_CONFIG]
new_params = {}
for key, val in SIMULATOR_PARAMETERS.iteritems():
new_params[key] = {'value': val}
new_params['connectivity'] = {'value': self.connectivity.gid}
# Simulate selection of a specific integration from the ui
new_params[PARAM_INTEGRATOR] = {'value': EulerStochastic.__name__}
new_params[PARAM_MODEL] = {'value': Generic2dOscillator.__name__}
new_params[INTEGRATOR_PARAMETERS + '_option_EulerStochastic_noise'] = {'value': Additive.__name__}
stored_burst.simulator_configuration = new_params
self.noise_c.index()
