def update():
"""
Update TVB code to SVN revision version 4455.
This update was done for release 1.0.2.
"""
projects_count = dao.get_all_projects(is_count=True)
for page_start in range(0, projects_count, PAGE_SIZE):
projects_page = dao.get_all_projects(page_start=page_start,
page_size=PAGE_SIZE)
for project in projects_page:
try:
user = dao.get_system_user()
adapter = ObjSurfaceImporter()
OperationService().fire_operation(adapter,
user,
project.id,
visible=False,
surface_type=EEG_CAP,
data_file=DATA_FILE_EEG_CAP)
adapter = ObjSurfaceImporter()
OperationService().fire_operation(adapter,
user,
project.id,
visible=False,
surface_type=FACE,
data_file=DATA_FILE_FACE)
except Exception as excep:
LOGGER.exception(excep)
TvbProfile.current.manager.add_entries_to_config_file(
{stored.KEY_MATLAB_EXECUTABLE: get_matlab_executable()})
def dec(*args, **kwargs):
session_maker = SessionMaker()
cfg.ALLOW_NESTED_TRANSACTIONS = True
default_dir = cfg.CURRENT_DIR
default_mlab_exe = cfg.MATLAB_EXECUTABLE
cfg.MATLAB_EXECUTABLE = get_matlab_executable()
session_maker.start_transaction()
try:
try:
if hasattr(args[0], 'setUpTVB'):
args[0].setUpTVB()
result = func(*args, **kwargs)
finally:
if hasattr(args[0], 'tearDownTVB'):
args[0].tearDownTVB()
args[0].delete_project_folders()
finally:
session_maker.rollback_transaction()
session_maker.close_transaction()
cfg.ALLOW_NESTED_TRANSACTIONS = False
cfg.MATLAB_EXECUTABLE = default_mlab_exe
cfg.CURRENT_DIR = default_dir
if callback is not None:
callback(*args, **kwargs)
return result
def initialize_profile(self, change_logger_in_dev=False):
super(
TestSQLiteProfile,
self).initialize_profile(change_logger_in_dev=change_logger_in_dev)
from tvb.core.utils import get_matlab_executable
self.MATLAB_EXECUTABLE = get_matlab_executable()
def init_test_env():
"""
This method prepares all necessary data for tests execution
"""
default_mlab_exe = cfg.MATLAB_EXECUTABLE
cfg.MATLAB_EXECUTABLE = get_matlab_executable()
reset_database()
initialize(["tvb.config", "tvb_test"], load_xml_events=False)
cfg.MATLAB_EXECUTABLE = default_mlab_exe
def test_check_matlab_path(self):
"""
Test that for a various Matlab paths, the correct check response is returned.
"""
submit_data = {stored.KEY_MATLAB_EXECUTABLE: get_matlab_executable()}
result = json.loads(self.settings_c.validate_matlab_path(**submit_data))
self.assertEqual(result['status'], 'ok')
submit_data[stored.KEY_MATLAB_EXECUTABLE] = "/this/path/should/be/invalid"
result = json.loads(self.settings_c.validate_matlab_path(**submit_data))
self.assertEqual(result['status'], 'not ok')
from tvb.core.utils import get_matlab_executable
from tvb.core.services.event_handlers import handle_event
from tvb.core.entities.storage import dao
LOGGER = get_logger(__name__)
PAGE_SIZE = 20
EVENT_FILE_IDENTIFIER = "CodeVersionsManager.update.4455"
def update():
"""
Update TVB code to SVN revision version 4455.
This update was done for release 1.0.2.
"""
projects_count = dao.get_all_projects(is_count=True)
for page_start in range(0, projects_count, PAGE_SIZE):
projects_page = dao.get_all_projects(page_start=page_start,
page_end=min(page_start + PAGE_SIZE, projects_count))
for project in projects_page:
try:
handle_event(EVENT_FILE_IDENTIFIER, dao.get_system_user(), project)
except Exception, excep:
LOGGER.exception(excep)
TvbProfile.current.manager.add_entries_to_config_file({stored.KEY_MATLAB_EXECUTABLE: get_matlab_executable()})
class BCTTest(TransactionalTestCase):
"""
Test that all BCT analyzers are executed without error.
We do not verify that the algorithms are correct, because that is outside the purpose of TVB framework.
"""
EXPECTED_TO_FAIL_VALIDATION = [
"CentralityKCoreness", "CentralityEigenVector",
"ClusteringCoefficientBU", "ClusteringCoefficientWU",
"TransitivityBinaryUnDirected", "TransitivityWeightedUnDirected"
]
@unittest.skipIf(get_matlab_executable() is None,
"Matlab or Octave not installed!")
def setUp(self):
"""
Sets up the environment for running the tests;
creates a test user, a test project, a connectivity and a list of BCT adapters;
imports a CFF data-set
"""
self.test_user = TestFactory.create_user("BCT_User")
self.test_project = TestFactory.create_project(self.test_user,
"BCT-Project")
### Make sure Connectivity is in DB
TestFactory.import_cff(test_user=self.test_user,
test_project=self.test_project)
self.connectivity = dao.get_generic_entity(Connectivity, 'John Doe',
'subject')[0]
# make weights matrix symmetric, or else some BCT algorithms will run infinitely:
w = self.connectivity.weights
self.connectivity.weights = w + w.T - numpy.diag(w.diagonal())
algorithms = dao.get_generic_entity(model.Algorithm,
'Brain Connectivity Toolbox',
'group_description')
self.assertTrue(algorithms is not None)
self.assertTrue(len(algorithms) > 5)
self.bct_adapters = []
for algo in algorithms:
self.bct_adapters.append(ABCAdapter.build_adapter(algo))
def tearDown(self):
"""
Cleans the database after the tests
"""
self.clean_database(True)
@unittest.skipIf(get_matlab_executable() is None,
"Matlab or Octave not installed!")
def test_bct_all(self):
"""
Iterate all BCT algorithms and execute them.
"""
for adapter_instance in self.bct_adapters:
algorithm = adapter_instance.stored_adapter
operation = TestFactory.create_operation(
algorithm=algorithm,
test_user=self.test_user,
test_project=self.test_project,
operation_status=model.STATUS_STARTED)
self.assertEqual(model.STATUS_STARTED, operation.status)
### Launch BCT algorithm
submit_data = {algorithm.parameter_name: self.connectivity.gid}
try:
OperationService().initiate_prelaunch(operation,
adapter_instance, {},
**submit_data)
if algorithm.classname in BCTTest.EXPECTED_TO_FAIL_VALIDATION:
raise Exception(
"Algorithm %s was expected to throw input validation "
"exception, but did not!" % (algorithm.classname, ))
operation = dao.get_operation_by_id(operation.id)
### Check that operation status after execution is success.
self.assertEqual(STATUS_FINISHED, operation.status)
### Make sure at least one result exists for each BCT algorithm
results = dao.get_generic_entity(model.DataType, operation.id,
'fk_from_operation')
self.assertTrue(len(results) > 0)
except InvalidParameterException, excep:
## Some algorithms are expected to throw validation exception.
if algorithm.classname not in BCTTest.EXPECTED_TO_FAIL_VALIDATION:
raise excep
from tvb.core.utils import get_matlab_executable
from tvb.core.services.event_handlers import handle_event
from tvb.core.entities.storage import dao
LOGGER = get_logger(__name__)
PAGE_SIZE = 20
EVENT_FILE_IDENTIFIER = "CodeVersionsManager.update.4455"
def update():
"""
Update TVB code to SVN revision version 4455.
This update was done for release 1.0.2.
"""
projects_count = dao.get_all_projects(is_count=True)
for page_start in range(0, projects_count, PAGE_SIZE):
projects_page = dao.get_all_projects(page_start=page_start,
page_end=min(page_start + PAGE_SIZE, projects_count))
for project in projects_page:
try:
handle_event(EVENT_FILE_IDENTIFIER, dao.get_system_user(), project)
except Exception, excep:
LOGGER.exception(excep)
cfg.add_entries_to_config_file({cfg.KEY_MATLAB_EXECUTABLE: get_matlab_executable()})
def initialize_profile(self, change_logger_in_dev=False):
super(TestSQLiteProfile, self).initialize_profile(change_logger_in_dev=change_logger_in_dev)
from tvb.core.utils import get_matlab_executable
self.MATLAB_EXECUTABLE = get_matlab_executable()
import cherrypy
import shutil
from types import FunctionType
from tvb.basic.config.utils import EnhancedDictionary
from tvb.basic.config.settings import TVBSettings as cfg
from tvb.basic.logger.builder import get_logger
from tvb.core.utils import get_matlab_executable
from tvb.core.entities.storage import dao
from tvb.core.entities.storage.sessionmaker import SessionMaker
from tvb.core.entities import model
from tvb.core.entities.modelmanager import reset_database
from tvb.core.services.initializer import initialize
from tvb.core.services.operationservice import OperationService
LOGGER = get_logger(__name__)
MATLAB_EXECUTABLE = get_matlab_executable()
def init_test_env():
"""
This method prepares all necessary data for tests execution
"""
default_mlab_exe = cfg.MATLAB_EXECUTABLE
cfg.MATLAB_EXECUTABLE = get_matlab_executable()
reset_database()
initialize(["tvb.config", "tvb_test"], load_xml_events=False)
cfg.MATLAB_EXECUTABLE = default_mlab_exe
def transactional_test(func, callback=None):
"""
class SettingsControllerTest(BaseTransactionalControllerTest):
"""
Unit tests for SettingsController class
"""
was_reset = False
accepted_db_url = ('sqlite:///TestFolder' + os.path.sep + 'tvb-database.db'
if TvbProfile.current.db.SELECTED_DB == 'sqlite'
else TvbProfile.current.db.DB_URL)
VALID_SETTINGS = {'TVB_STORAGE': "TestFolder",
'USR_DISK_SPACE': 1,
'MAXIMUM_NR_OF_THREADS': 6,
'MAXIMUM_NR_OF_VERTICES_ON_SURFACE': 142,
'MAXIMUM_NR_OF_OPS_IN_RANGE': 16,
'MATLAB_EXECUTABLE': '',
'DEPLOY_CLUSTER': 'True',
'SELECTED_DB': TvbProfile.current.db.SELECTED_DB, # Not changeable,due to test profile overwrites
'URL_VALUE': accepted_db_url,
'URL_WEB': "http://*****:*****@test.test'}
def setUp(self):
self.init(with_data=False)
self.settings_c = SettingsController()
self.assertTrue(TvbProfile.is_first_run())
def tearDown(self):
""" Cleans the testing environment """
self.cleanup()
if os.path.exists(self.VALID_SETTINGS['TVB_STORAGE']):
shutil.rmtree(self.VALID_SETTINGS['TVB_STORAGE'])
def test_with_invalid_admin_settings(self):
self._assert_invalid_parameters({'ADMINISTRATOR_NAME': '',
'ADMINISTRATOR_PASSWORD': '',
'ADMINISTRATOR_EMAIL': ''})
self._assert_invalid_parameters({'ADMINISTRATOR_EMAIL': "bla.com"})
def test_with_invalid_web_settings(self):
self._assert_invalid_parameters({'URL_WEB': '',
'WEB_SERVER_PORT': 'a'})
self._assert_invalid_parameters({'URL_WEB': 'off://bla',
'WEB_SERVER_PORT': '70000'})
def test_with_invalid_settings(self):
self._assert_invalid_parameters({'TVB_STORAGE': '',
'SELECTED_DB': '',
'URL_VALUE': ''})
self._assert_invalid_parameters({'USR_DISK_SPACE': '',
'MAXIMUM_NR_OF_THREADS': '0',
'MAXIMUM_NR_OF_VERTICES_ON_SURFACE': '-1',
'MAXIMUM_NR_OF_OPS_IN_RANGE': '2'})
self._assert_invalid_parameters({'USR_DISK_SPACE': 'a',
'MAXIMUM_NR_OF_THREADS': '20',
'MAXIMUM_NR_OF_VERTICES_ON_SURFACE': str(256 * 256 * 256 + 1),
'MAXIMUM_NR_OF_OPS_IN_RANGE': '10000'})
self._assert_invalid_parameters({'MAXIMUM_NR_OF_THREADS': 'c',
'MAXIMUM_NR_OF_VERTICES_ON_SURFACE': 'b',
'MAXIMUM_NR_OF_OPS_IN_RANGE': 'a'})
def _assert_invalid_parameters(self, params_dictionary):
"""
Simulate submit of a given params (key:value) and check that they are found in the error response
"""
submit_data = copy.copy(self.VALID_SETTINGS)
for key, value in params_dictionary.iteritems():
submit_data[key] = value
response = self.settings_c.settings(save_settings=True, **submit_data)
self.assertTrue(common.KEY_ERRORS in response)
for key in params_dictionary:
self.assertTrue(key in response[common.KEY_ERRORS], "Not found in errors %s" % key)
def test_with_valid_settings(self):
submit_data = self.VALID_SETTINGS
self.settings_c._restart_services = self._fake_restart_services
self.assertRaises(cherrypy.HTTPRedirect, self.settings_c.settings, save_settings=True, **self.VALID_SETTINGS)
# wait until 'restart' is done
sleep(1)
self.assertTrue(self.was_reset)
self.assertEqual(16, len(TvbProfile.current.manager.stored_settings))
self.assertEqual(submit_data['TVB_STORAGE'], TvbProfile.current.TVB_STORAGE)
self.assertEqual(submit_data['USR_DISK_SPACE'] * 2 ** 10, TvbProfile.current.MAX_DISK_SPACE)
self.assertEqual(submit_data['MAXIMUM_NR_OF_THREADS'], TvbProfile.current.MAX_THREADS_NUMBER)
self.assertEqual(submit_data['MAXIMUM_NR_OF_OPS_IN_RANGE'], TvbProfile.current.MAX_RANGE_NUMBER)
self.assertEqual(submit_data['MAXIMUM_NR_OF_VERTICES_ON_SURFACE'],
TvbProfile.current.MAX_SURFACE_VERTICES_NUMBER)
self.assertEqual(submit_data['DEPLOY_CLUSTER'], str(TvbProfile.current.cluster.IS_DEPLOY))
self.assertEqual(submit_data['SELECTED_DB'], TvbProfile.current.db.SELECTED_DB)
self.assertEqual(submit_data['URL_VALUE'], TvbProfile.current.db.DB_URL)
self.assertEqual(submit_data['URL_WEB'], TvbProfile.current.web.BASE_URL)
self.assertEqual(submit_data['WEB_SERVER_PORT'], TvbProfile.current.web.SERVER_PORT)
self.assertEqual(submit_data['ADMINISTRATOR_NAME'], TvbProfile.current.web.admin.ADMINISTRATOR_NAME)
self.assertEqual(submit_data['ADMINISTRATOR_EMAIL'], TvbProfile.current.web.admin.ADMINISTRATOR_EMAIL)
self.assertEqual(md5(submit_data['ADMINISTRATOR_PASSWORD']).hexdigest(),
TvbProfile.current.web.admin.ADMINISTRATOR_PASSWORD)
def _fake_restart_services(self, should_reset):
"""
This function will replace the SettingsController._restart_service method,
to avoid problems in tests due to restart.
"""
self.was_reset = should_reset
TvbProfile._build_profile_class(TvbProfile.CURRENT_PROFILE_NAME)
def test_check_db_url(self):
"""
Test that for a various DB URLs, the correct check response is returned.
"""
submit_data = {stored.KEY_STORAGE: TvbProfile.current.TVB_STORAGE,
stored.KEY_DB_URL: TvbProfile.current.db.DB_URL}
result = json.loads(self.settings_c.check_db_url(**submit_data))
self.assertEqual(result['status'], 'ok')
submit_data[stored.KEY_DB_URL] = "this URL should be invalid"
result = json.loads(self.settings_c.check_db_url(**submit_data))
self.assertEqual(result['status'], 'not ok')
@unittest.skipIf(get_matlab_executable() is None, "Matlab or Octave not installed!")
def test_check_matlab_path(self):
"""
Test that for a various Matlab paths, the correct check response is returned.
"""
submit_data = {stored.KEY_MATLAB_EXECUTABLE: get_matlab_executable()}
result = json.loads(self.settings_c.validate_matlab_path(**submit_data))
self.assertEqual(result['status'], 'ok')
submit_data[stored.KEY_MATLAB_EXECUTABLE] = "/this/path/should/be/invalid"
result = json.loads(self.settings_c.validate_matlab_path(**submit_data))
self.assertEqual(result['status'], 'not ok')
def update():
"""
Update TVB code to SVN revision version 4455.
This update was done for release 1.0.2.
"""
projects_count = dao.get_all_projects(is_count=True)
for page_start in range(0, projects_count, PAGE_SIZE):
projects_page = dao.get_all_projects(page_start=page_start, page_size=PAGE_SIZE)
for project in projects_page:
try:
user = dao.get_system_user()
adapter = ObjSurfaceImporter()
FlowService().fire_operation(adapter, user, project.id, visible=False,
surface_type=EEG_CAP, data_file=DATA_FILE_EEG_CAP)
adapter = ObjSurfaceImporter()
FlowService().fire_operation(adapter, user, project.id, visible=False,
surface_type=FACE, data_file=DATA_FILE_FACE)
except Exception as excep:
LOGGER.exception(excep)
TvbProfile.current.manager.add_entries_to_config_file({stored.KEY_MATLAB_EXECUTABLE: get_matlab_executable()})
def __init__(self):
self.logger = get_logger(__name__)
first_run = TvbProfile.is_first_run()
storage = TvbProfile.current.TVB_STORAGE if not first_run else TvbProfile.current.DEFAULT_STORAGE
self.configurable_keys = {
self.KEY_STORAGE: {
'label': 'Root folder for all projects',
'value': storage,
'readonly': not first_run,
'type': 'text'
},
self.KEY_MAX_DISK_SPACE_USR: {
'label': 'Max hard disk space per user (MBytes)',
'value': TvbProfile.current.MAX_DISK_SPACE / 2**10,
'type': 'text'
},
self.KEY_MATLAB_EXECUTABLE: {
'label':
'Optional Matlab or Octave path',
'type':
'text',
'value':
TvbProfile.current.MATLAB_EXECUTABLE
or get_matlab_executable() or '',
'description':
'Some analyzers will not be available when '
'matlab/octave are not found'
},
self.KEY_SELECTED_DB: {
'label': 'Select one DB engine',
'value': TvbProfile.current.db.SELECTED_DB,
'type': 'select',
'readonly': not first_run,
'options': TvbProfile.current.db.ACEEPTED_DBS
},
self.KEY_DB_URL: {
'label':
"DB connection URL",
'value':
TvbProfile.current.db.ACEEPTED_DBS[
TvbProfile.current.db.SELECTED_DB],
'type':
'text',
'readonly':
TvbProfile.current.db.SELECTED_DB == 'sqlite'
},
self.KEY_PORT: {
'label': 'Port to run Cherrypy on',
'value': TvbProfile.current.web.SERVER_PORT,
'dtype': 'primitive',
'type': 'text'
},
self.KEY_PORT_MPLH5: {
'label': 'Port to run Matplotlib on',
'type': 'text',
'dtype': 'primitive',
'value': TvbProfile.current.web.MPLH5_SERVER_PORT
},
self.KEY_URL_WEB: {
'label': 'URL for accessing web',
'value': TvbProfile.current.web.BASE_URL,
'type': 'text',
'dtype': 'primitive'
},
self.KEY_URL_MPLH5: {
'label': 'URL for accessing MPLH5 visualizers',
'type': 'text',
'value': TvbProfile.current.web.MPLH5_SERVER_URL,
'dtype': 'primitive'
},
self.KEY_MAX_NR_THREADS: {
'label': 'Maximum no. of threads for local installations',
'type': 'text',
'value': TvbProfile.current.MAX_THREADS_NUMBER,
'dtype': 'primitive'
},
self.KEY_MAX_RANGE: {
'label': 'Maximum no. of operations in one PSE',
'description':
"Parameters Space Exploration (PSE) maximum number of operations",
'value': TvbProfile.current.MAX_RANGE_NUMBER,
'type': 'text',
'dtype': 'primitive'
},
self.KEY_MAX_NR_SURFACE_VERTEX: {
'label': 'Maximum no. of vertices in a surface',
'type': 'text',
'dtype': 'primitive',
'value': TvbProfile.current.MAX_SURFACE_VERTICES_NUMBER
},
self.KEY_CLUSTER: {
'label': 'Deploy on cluster',
'value': TvbProfile.current.cluster.IS_DEPLOY,
'description':
'Check this only if on the web-server machine OARSUB command is enabled.',
'dtype': 'primitive',
'type': 'boolean'
},
self.KEY_ADMIN_NAME: {
'label':
'Administrator User Name',
'value':
TvbProfile.current.web.admin.ADMINISTRATOR_NAME,
'type':
'text',
'readonly':
not first_run,
'description':
('Password and Email can be edited after first run, '
'from the profile page directly.')
},
self.KEY_ADMIN_PWD: {
'label':
'Password',
'value':
TvbProfile.current.web.admin.ADMINISTRATOR_BLANK_PWD
if first_run else
TvbProfile.current.web.admin.ADMINISTRATOR_PASSWORD,
'type':
'password',
'readonly':
not first_run
},
self.KEY_ADMIN_EMAIL: {
'label': 'Administrator Email',
'value': TvbProfile.current.web.admin.ADMINISTRATOR_EMAIL,
'readonly': not first_run,
'type': 'text'
}
}
operation = dao.get_operation_by_id(operation.id)
### Check that operation status after execution is success.
self.assertEqual(STATUS_FINISHED, operation.status)
### Make sure at least one result exists for each BCT algorithm
results = dao.get_generic_entity(model.DataType,
operation.id,
'fk_from_operation')
self.assertTrue(len(results) > 0)
except InvalidParameterException, excep:
## Some algorithms are expected to throw validation exception.
if bct_identifier not in BCTTest.EXPECTED_TO_FAIL_VALIDATION:
raise excep
@unittest.skipIf(get_matlab_executable() is None,
"Matlab or Octave not installed!")
def test_bct_descriptions(self):
"""
Iterate all BCT algorithms and check description not empty.
"""
for i in xrange(len(self.bct_adapters)):
for bct_identifier in self.bct_adapters[
i].get_algorithms_dictionary():
### Prepare Operation and parameters
algorithm = dao.get_algorithm_by_group(self.algo_groups[i].id,
bct_identifier)
self.assertTrue(
len(algorithm.description) > 0,
"Description was not loaded properly for algorithm %s" %
(str(algorithm, )))
"exception, but did not!" % (algorithm.classname,))
operation = dao.get_operation_by_id(operation.id)
### Check that operation status after execution is success.
self.assertEqual(STATUS_FINISHED, operation.status)
### Make sure at least one result exists for each BCT algorithm
results = dao.get_generic_entity(model.DataType, operation.id, 'fk_from_operation')
self.assertTrue(len(results) > 0)
except InvalidParameterException, excep:
## Some algorithms are expected to throw validation exception.
if algorithm.classname not in BCTTest.EXPECTED_TO_FAIL_VALIDATION:
raise excep
@unittest.skipIf(get_matlab_executable() is None, "Matlab or Octave not installed!")
def test_bct_descriptions(self):
"""
Iterate all BCT algorithms and check that description has been extracted from *.m files.
"""
for adapter_instance in self.bct_adapters:
self.assertTrue(len(adapter_instance.stored_adapter.description) > 10,
"Description was not loaded properly for algorithm %s" % (str(adapter_instance)))
def suite():
"""
Gather all the tests in a test suite.
"""
test_suite = unittest.TestSuite()
test_suite.addTest(unittest.makeSuite(BCTTest))
from tvb.basic.logger.builder import get_logger
from tvb.basic.config.settings import TVBSettings as cfg
from tvb.core.utils import get_matlab_executable
from tvb.core.entities.storage import dao
LOGGER = get_logger(__name__)
PAGE_SIZE = 20
EVENT_FILE_IDENTIFIER = "CodeVersionsManager.update.4455"
def update():
"""
Update TVB code to SVN revision version 4455.
This update was done for release 1.0.2.
"""
projects_count = dao.get_all_projects(is_count=True)
for page_start in range(0, projects_count, PAGE_SIZE):
projects_page = dao.get_all_projects(page_start=page_start, page_end=min(page_start +PAGE_SIZE, projects_count))
for project in projects_page:
try:
eventhandler.handle_event(EVENT_FILE_IDENTIFIER, dao.get_system_user(), project)
except Exception, excep:
LOGGER.exception(excep)
cfg.add_entries_to_config_file({cfg.KEY_MATLAB_EXECUTABLE : get_matlab_executable()})
class TestBCT(TransactionalTestCase):
"""
Test that all BCT analyzers are executed without error.
We do not verify that the algorithms are correct, because that is outside the purpose of TVB framework.
"""
@pytest.mark.skipif(get_matlab_executable() is None, reason="Matlab or Octave not installed!")
def transactional_setup_method(self):
"""
Sets up the environment for running the tests;
creates a test user, a test project, a connectivity and a list of BCT adapters;
imports a CFF data-set
"""
self.test_user = TestFactory.create_user("BCT_User")
self.test_project = TestFactory.create_project(self.test_user, "BCT-Project")
# Make sure Connectivity is in DB
zip_path = os.path.join(os.path.dirname(tvb_data.__file__), 'connectivity', 'connectivity_76.zip')
self.connectivity = TestFactory.import_zip_connectivity(self.test_user, self.test_project, zip_path)
algorithms = dao.get_generic_entity(Algorithm, 'Brain Connectivity Toolbox', 'group_description')
assert algorithms is not None
assert len(algorithms) > 5
self.bct_adapters = []
for algo in algorithms:
self.bct_adapters.append(ABCAdapter.build_adapter(algo))
def transactional_teardown_method(self):
"""
Cleans the database after the tests
"""
self.clean_database(True)
@pytest.mark.skipif(get_matlab_executable() is None, reason="Matlab or Octave not installed!")
def test_bct_all(self):
"""
Iterate all BCT algorithms and execute them.
"""
service = OperationService()
algo_category = dao.get_category_by_id(self.bct_adapters[0].stored_adapter.fk_category)
for adapter_instance in self.bct_adapters:
algorithm = adapter_instance.stored_adapter
view_model = BaseBCTModel()
view_model.connectivity = self.connectivity.gid
# Avoid the scheduled execution, as this is asynch, thus launch it immediately
operation = service.prepare_operations(self.test_user.id, self.test_project, algorithm, algo_category,
{}, True, view_model=view_model)[0][0]
service.initiate_prelaunch(operation, adapter_instance)
operation = dao.get_operation_by_id(operation.id)
# Check that operation status after execution is success.
assert STATUS_FINISHED == operation.status
# Make sure at least one result exists for each BCT algorithm
results = dao.get_generic_entity(DataType, operation.id, 'fk_from_operation')
assert len(results) > 0
@pytest.mark.skipif(get_matlab_executable() is None, reason="Matlab or Octave not installed!")
def test_bct_descriptions(self):
"""
Iterate all BCT algorithms and check that description has been extracted from *.m files.
"""
for adapter_instance in self.bct_adapters:
assert len(adapter_instance.stored_adapter.description) > 10, "Description was not loaded properly for " \
"algorithm %s" % (str(adapter_instance))
class BCTTest(TransactionalTestCase):
"""
Test that all BCT analyzers are executed without error.
We do not verify that the algorithms are correct, because that is outside the purpose of TVB framework.
"""
EXPECTED_TO_FAIL_VALIDATION = [
"CCBU", "CCWU", "EIGUN", "KCCBU", "TBU", "TWU"
]
@unittest.skipIf(get_matlab_executable() is None,
"Matlab or Octave not installed!")
def setUp(self):
"""
Sets up the environment for running the tests;
creates a test user, a test project, a connectivity and a list of BCT adapters;
imports a CFF data-set
"""
self.test_user = TestFactory.create_user("BCT_User")
self.test_project = TestFactory.create_project(self.test_user,
"BCT-Project")
### Make sure Connectivity is in DB
TestFactory.import_cff(test_user=self.test_user,
test_project=self.test_project)
self.connectivity = dao.get_generic_entity(Connectivity, 'John Doe',
'subject')[0]
# make weights matrix symmetric, or else some BCT algorithms will run infinitely:
w = self.connectivity.weights
self.connectivity.weights = w + w.T - numpy.diag(w.diagonal())
self.algo_groups = dao.get_generic_entity(model.AlgorithmGroup,
'MatlabAdapter', 'classname')
self.assertTrue(self.algo_groups is not None)
self.assertEquals(6, len(self.algo_groups))
self.bct_adapters = []
for group in self.algo_groups:
self.bct_adapters.append(
TestFactory.create_adapter(group, self.test_project))
def tearDown(self):
"""
Cleans the database after the tests
"""
self.clean_database(True)
@unittest.skipIf(get_matlab_executable() is None,
"Matlab or Octave not installed!")
def test_bct_all(self):
"""
Iterate all BCT algorithms and execute them.
"""
for i in xrange(len(self.bct_adapters)):
for bct_identifier in self.bct_adapters[
i].get_algorithms_dictionary():
### Prepare Operation and parameters
algorithm = dao.get_algorithm_by_group(self.algo_groups[i].id,
bct_identifier)
operation = TestFactory.create_operation(
algorithm=algorithm,
test_user=self.test_user,
test_project=self.test_project,
operation_status=model.STATUS_STARTED)
self.assertEqual(model.STATUS_STARTED, operation.status)
### Launch BCT algorithm
submit_data = {
self.algo_groups[i].algorithm_param_name: bct_identifier,
algorithm.parameter_name: self.connectivity.gid
}
try:
OperationService().initiate_prelaunch(
operation, self.bct_adapters[i], {}, **submit_data)
if bct_identifier in BCTTest.EXPECTED_TO_FAIL_VALIDATION:
raise Exception(
"Algorithm %s was expected to throw input validation "
"exception, but did not!" % (bct_identifier, ))
operation = dao.get_operation_by_id(operation.id)
### Check that operation status after execution is success.
self.assertEqual(STATUS_FINISHED, operation.status)
### Make sure at least one result exists for each BCT algorithm
results = dao.get_generic_entity(model.DataType,
operation.id,
'fk_from_operation')
self.assertTrue(len(results) > 0)
except InvalidParameterException, excep:
## Some algorithms are expected to throw validation exception.
if bct_identifier not in BCTTest.EXPECTED_TO_FAIL_VALIDATION:
raise excep
def __init__(self):
self.logger = get_logger(__name__)
first_run = TvbProfile.is_first_run()
storage = TvbProfile.current.TVB_STORAGE if not first_run else TvbProfile.current.DEFAULT_STORAGE
self.configurable_keys = {
self.KEY_STORAGE: {'label': 'Root folder for all projects', 'value': storage,
'readonly': not first_run, 'type': 'text'},
self.KEY_MAX_DISK_SPACE_USR: {'label': 'Max hard disk space per user (MBytes)',
'value': TvbProfile.current.MAX_DISK_SPACE / 2 ** 10, 'type': 'text'},
self.KEY_MATLAB_EXECUTABLE: {'label': 'Optional Matlab or Octave path', 'type': 'text',
'value': TvbProfile.current.MATLAB_EXECUTABLE or get_matlab_executable() or '',
'description': 'Some analyzers will not be available when '
'matlab/octave are not found'},
self.KEY_SELECTED_DB: {'label': 'Select one DB engine', 'value': TvbProfile.current.db.SELECTED_DB,
'type': 'select', 'readonly': not first_run,
'options': TvbProfile.current.db.ACEEPTED_DBS},
self.KEY_DB_URL: {'label': "DB connection URL",
'value': TvbProfile.current.db.ACEEPTED_DBS[TvbProfile.current.db.SELECTED_DB],
'type': 'text', 'readonly': TvbProfile.current.db.SELECTED_DB == 'sqlite'},
self.KEY_PORT: {'label': 'Port to run Cherrypy on',
'value': TvbProfile.current.web.SERVER_PORT, 'dtype': 'primitive', 'type': 'text'},
self.KEY_URL_WEB: {'label': 'URL for accessing web',
'value': TvbProfile.current.web.BASE_URL, 'type': 'text', 'dtype': 'primitive'},
self.KEY_MAX_NR_THREADS: {'label': 'Maximum no. of threads for local installations', 'type': 'text',
'value': TvbProfile.current.MAX_THREADS_NUMBER, 'dtype': 'primitive'},
self.KEY_MAX_RANGE: {'label': 'Maximum no. of operations in one PSE',
'description': "Parameters Space Exploration (PSE) maximum number of operations",
'value': TvbProfile.current.MAX_RANGE_NUMBER, 'type': 'text', 'dtype': 'primitive'},
self.KEY_MAX_NR_SURFACE_VERTEX: {'label': 'Maximum no. of vertices in a surface',
'type': 'text', 'dtype': 'primitive',
'value': TvbProfile.current.MAX_SURFACE_VERTICES_NUMBER},
self.KEY_CLUSTER: {'label': 'Deploy on cluster', 'value': TvbProfile.current.cluster.IS_DEPLOY,
'description': 'Check this only if on the web-server machine OARSUB command is enabled.',
'dtype': 'primitive', 'type': 'boolean'},
self.KEY_ADMIN_NAME: {'label': 'Administrator User Name',
'value': TvbProfile.current.web.admin.ADMINISTRATOR_NAME,
'type': 'text', 'readonly': not first_run,
'description': ('Password and Email can be edited after first run, '
'from the profile page directly.')},
self.KEY_ADMIN_PWD: {'label': 'Password',
'value': TvbProfile.current.web.admin.ADMINISTRATOR_BLANK_PWD if first_run
else TvbProfile.current.web.admin.ADMINISTRATOR_PASSWORD,
'type': 'password', 'readonly': not first_run},
self.KEY_ADMIN_EMAIL: {'label': 'Administrator Email',
'value': TvbProfile.current.web.admin.ADMINISTRATOR_EMAIL,
'readonly': not first_run, 'type': 'text'}}
from tvb.basic.profile import TvbProfile
from tvb.core.utils import get_matlab_executable
from tvb.core.services.event_handlers import handle_event
from tvb.core.entities.storage import dao
LOGGER = get_logger(__name__)
PAGE_SIZE = 20
EVENT_FILE_IDENTIFIER = "CodeVersionsManager.update.4455"
def update():
"""
Update TVB code to SVN revision version 4455.
This update was done for release 1.0.2.
"""
projects_count = dao.get_all_projects(is_count=True)
for page_start in range(0, projects_count, PAGE_SIZE):
projects_page = dao.get_all_projects(page_start=page_start,
page_size=PAGE_SIZE)
for project in projects_page:
try:
handle_event(EVENT_FILE_IDENTIFIER, dao.get_system_user(),
project)
except Exception, excep:
LOGGER.exception(excep)
TvbProfile.current.manager.add_entries_to_config_file(
{stored.KEY_MATLAB_EXECUTABLE: get_matlab_executable()})
class TestSettingsController(BaseTransactionalControllerTest):
"""
Unit tests for SettingsController class
"""
was_reset = False
storage = str(Path.home()) + os.path.sep + "TestFolder"
accepted_db_url = ('sqlite:///' + storage + os.path.sep +
'tvb-database.db' if TvbProfile.current.db.SELECTED_DB
== 'sqlite' else TvbProfile.current.db.DB_URL)
VALID_SETTINGS = {
'KEYCLOAK_CONFIGURATION':
storage + os.path.sep + 'keycloak-config.json',
'KEYCLOAK_WEB_CONFIGURATION':
storage + os.path.sep + 'keycloak-web-config.json',
'TVB_STORAGE': storage,
'USR_DISK_SPACE': 1,
'MAXIMUM_NR_OF_THREADS': 6,
'MAXIMUM_NR_OF_VERTICES_ON_SURFACE': 142,
'MAXIMUM_NR_OF_OPS_IN_RANGE': 16,
'MATLAB_EXECUTABLE': '',
'DEPLOY_CLUSTER': 'True',
'CLUSTER_SCHEDULER': TvbProfile.current.cluster.SCHEDULER_OAR,
'SELECTED_DB': TvbProfile.current.db.
SELECTED_DB, # Not changeable,due to test profile overwrites
'URL_VALUE': accepted_db_url,
'WEB_SERVER_PORT': 9999,
'ADMINISTRATOR_NAME': 'test_admin',
'ADMINISTRATOR_DISPLAY_NAME': 'test_Administrator',
'ADMINISTRATOR_PASSWORD': "******",
'ADMINISTRATOR_EMAIL': '*****@*****.**'
}
def transactional_setup_method(self):
self.init(with_data=False)
self.settings_c = SettingsController()
assert TvbProfile.is_first_run()
def transactional_teardown_method(self):
""" Cleans the testing environment """
self.cleanup()
self.clean_database()
if os.path.exists(self.VALID_SETTINGS['TVB_STORAGE']):
shutil.rmtree(self.VALID_SETTINGS['TVB_STORAGE'])
def test_with_invalid_admin_settings(self):
self._assert_invalid_parameters({
'ADMINISTRATOR_NAME': '',
'ADMINISTRATOR_PASSWORD': '',
'ADMINISTRATOR_EMAIL': ''
})
self._assert_invalid_parameters({'ADMINISTRATOR_EMAIL': "bla.com"})
def test_with_invalid_web_settings(self):
self._assert_invalid_parameters({'WEB_SERVER_PORT': 'a'})
self._assert_invalid_parameters({'WEB_SERVER_PORT': '70000'})
def test_with_invalid_settings(self):
self._assert_invalid_parameters({
'TVB_STORAGE': '',
'SELECTED_DB': '',
'URL_VALUE': ''
})
self._assert_invalid_parameters({
'USR_DISK_SPACE': '',
'MAXIMUM_NR_OF_THREADS': '0',
'MAXIMUM_NR_OF_VERTICES_ON_SURFACE': '-1',
'MAXIMUM_NR_OF_OPS_IN_RANGE': '2'
})
self._assert_invalid_parameters({
'USR_DISK_SPACE':
'a',
'MAXIMUM_NR_OF_THREADS':
'20',
'MAXIMUM_NR_OF_VERTICES_ON_SURFACE':
str(256 * 256 * 256 + 1),
'MAXIMUM_NR_OF_OPS_IN_RANGE':
'10000'
})
self._assert_invalid_parameters({
'MAXIMUM_NR_OF_THREADS': 'c',
'MAXIMUM_NR_OF_VERTICES_ON_SURFACE': 'b',
'MAXIMUM_NR_OF_OPS_IN_RANGE': 'a'
})
def _assert_invalid_parameters(self, params_dictionary):
"""
Simulate submit of a given params (key:value) and check that they are found in the error response
"""
submit_data = copy.copy(self.VALID_SETTINGS)
for key, value in params_dictionary.items():
submit_data[key] = value
response = self.settings_c.settings(save_settings=True, **submit_data)
assert common.KEY_ERRORS in response
for key in params_dictionary:
assert key in response[
common.KEY_ERRORS], "Not found in errors %s" % key
def test_with_valid_settings(self):
# Ensure we submit acceptable values, depending on the current profile (set-up after fixtures execution)
submit_data = copy.copy(self.VALID_SETTINGS)
accepted_db_url = ('sqlite:///' + self.storage + os.path.sep +
'tvb-database.db'
if TvbProfile.current.db.SELECTED_DB == 'sqlite'
else TvbProfile.current.db.DB_URL)
submit_data['SELECTED_DB'] = TvbProfile.current.db.SELECTED_DB
submit_data['URL_VALUE'] = accepted_db_url
self.settings_c._restart_services = self._fake_restart_services
with pytest.raises(cherrypy.HTTPRedirect):
self.settings_c.settings(save_settings=True, **self.VALID_SETTINGS)
# wait until 'restart' is done
sleep(1)
assert self.was_reset
assert len(TvbProfile.current.manager.stored_settings) == 21
assert submit_data['TVB_STORAGE'] == TvbProfile.current.TVB_STORAGE
assert submit_data[
'USR_DISK_SPACE'] * 2**10 == TvbProfile.current.MAX_DISK_SPACE
assert submit_data[
'MAXIMUM_NR_OF_THREADS'] == TvbProfile.current.MAX_THREADS_NUMBER
assert submit_data[
'MAXIMUM_NR_OF_OPS_IN_RANGE'] == TvbProfile.current.MAX_RANGE_NUMBER
assert submit_data[
'MAXIMUM_NR_OF_VERTICES_ON_SURFACE'] == TvbProfile.current.MAX_SURFACE_VERTICES_NUMBER
assert submit_data['DEPLOY_CLUSTER'] == str(
TvbProfile.current.cluster.IS_DEPLOY)
assert submit_data['SELECTED_DB'] == TvbProfile.current.db.SELECTED_DB
assert submit_data['URL_VALUE'] == TvbProfile.current.db.DB_URL
assert submit_data[
'WEB_SERVER_PORT'] == TvbProfile.current.web.SERVER_PORT
assert submit_data[
'ADMINISTRATOR_NAME'] == TvbProfile.current.web.admin.ADMINISTRATOR_NAME
assert submit_data[
'ADMINISTRATOR_EMAIL'] == TvbProfile.current.web.admin.ADMINISTRATOR_EMAIL
assert hash_password(
submit_data['ADMINISTRATOR_PASSWORD']
) == TvbProfile.current.web.admin.ADMINISTRATOR_PASSWORD
def _fake_restart_services(self, should_reset):
"""
This function will replace the SettingsController._restart_service method,
to avoid problems in tests due to restart.
"""
self.was_reset = should_reset
TvbProfile._build_profile_class(TvbProfile.CURRENT_PROFILE_NAME)
def test_check_db_url(self):
"""
Test that for a various DB URLs, the correct check response is returned.
"""
submit_data = {
stored.KEY_STORAGE: TvbProfile.current.TVB_STORAGE,
stored.KEY_DB_URL: TvbProfile.current.db.DB_URL
}
result = json.loads(self.settings_c.check_db_url(**submit_data))
assert result['status'] == 'ok'
submit_data[stored.KEY_DB_URL] = "this URL should be invalid"
result = json.loads(self.settings_c.check_db_url(**submit_data))
assert result['status'] == 'not ok'
@pytest.mark.skipif(get_matlab_executable() is None,
reason="Matlab or Octave not installed!")
def test_check_matlab_path(self):
"""
Test that for a various Matlab paths, the correct check response is returned.
"""
submit_data = {stored.KEY_MATLAB_EXECUTABLE: get_matlab_executable()}
result = json.loads(
self.settings_c.validate_matlab_path(**submit_data))
assert result['status'] == 'ok'
submit_data[
stored.KEY_MATLAB_EXECUTABLE] = "/this/path/should/be/invalid"
result = json.loads(
self.settings_c.validate_matlab_path(**submit_data))
assert result['status'] == 'not ok'
class TestBCT(TransactionalTestCase):
"""
Test that all BCT analyzers are executed without error.
We do not verify that the algorithms are correct, because that is outside the purpose of TVB framework.
"""
EXPECTED_TO_FAIL_VALIDATION = [
"CentralityKCoreness", "CentralityEigenVector",
"ClusteringCoefficientBU", "ClusteringCoefficientWU",
"TransitivityBinaryUnDirected", "TransitivityWeightedUnDirected"
]
@pytest.mark.skipif(get_matlab_executable() is None,
reason="Matlab or Octave not installed!")
def transactional_setup_method(self):
"""
Sets up the environment for running the tests;
creates a test user, a test project, a connectivity and a list of BCT adapters;
imports a CFF data-set
"""
self.test_user = TestFactory.create_user("BCT_User")
self.test_project = TestFactory.create_project(self.test_user,
"BCT-Project")
# Make sure Connectivity is in DB
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_66.zip')
conn_index = TestFactory.import_zip_connectivity(
self.test_user, self.test_project, zip_path)
self.connectivity = ABCAdapter.load_traited_by_gid(conn_index.gid)
# make weights matrix symmetric, or else some BCT algorithms will run infinitely:
w = self.connectivity.weights
self.connectivity.weights = w + w.T - numpy.diag(w.diagonal())
algorithms = dao.get_generic_entity(Algorithm,
'Brain Connectivity Toolbox',
'group_description')
assert algorithms is not None
assert len(algorithms) > 5
self.bct_adapters = []
for algo in algorithms:
self.bct_adapters.append(ABCAdapter.build_adapter(algo))
def transactional_teardown_method(self):
"""
Cleans the database after the tests
"""
self.clean_database(True)
@pytest.mark.skipif(get_matlab_executable() is None,
reason="Matlab or Octave not installed!")
def test_bct_all(self):
"""
Iterate all BCT algorithms and execute them.
"""
for adapter_instance in self.bct_adapters:
algorithm = adapter_instance.stored_adapter
operation = TestFactory.create_operation(
algorithm=algorithm,
test_user=self.test_user,
test_project=self.test_project,
operation_status=STATUS_STARTED)
assert STATUS_STARTED == operation.status
# Launch BCT algorithm
submit_data = {algorithm.parameter_name: self.connectivity.gid}
try:
OperationService().initiate_prelaunch(operation,
adapter_instance, {},
**submit_data)
if algorithm.classname in TestBCT.EXPECTED_TO_FAIL_VALIDATION:
raise Exception(
"Algorithm %s was expected to throw input validation "
"exception, but did not!" % (algorithm.classname, ))
operation = dao.get_operation_by_id(operation.id)
# Check that operation status after execution is success.
assert STATUS_FINISHED == operation.status
# Make sure at least one result exists for each BCT algorithm
results = dao.get_generic_entity(DataType, operation.id,
'fk_from_operation')
assert len(results) > 0
except InvalidParameterException as excep:
# Some algorithms are expected to throw validation exception.
if algorithm.classname not in TestBCT.EXPECTED_TO_FAIL_VALIDATION:
raise excep
@pytest.mark.skipif(get_matlab_executable() is None,
reason="Matlab or Octave not installed!")
def test_bct_descriptions(self):
"""
Iterate all BCT algorithms and check that description has been extracted from *.m files.
"""
for adapter_instance in self.bct_adapters:
assert len(adapter_instance.stored_adapter.description) > 10, "Description was not loaded properly for " \
"algorithm %s" % (str(adapter_instance))
"exception, but did not!" % (bct_identifier,))
operation = dao.get_operation_by_id(operation.id)
### Check that operation status after execution is success.
self.assertEqual(STATUS_FINISHED, operation.status)
### Make sure at least one result exists for each BCT algorithm
results = dao.get_generic_entity(model.DataType, operation.id, 'fk_from_operation')
self.assertTrue(len(results) > 0)
except InvalidParameterException, excep:
## Some algorithms are expected to throw validation exception.
if bct_identifier not in BCTTest.EXPECTED_TO_FAIL_VALIDATION:
raise excep
@unittest.skipIf(get_matlab_executable() is None, "Matlab or Octave not installed!")
def test_bct_descriptions(self):
"""
Iterate all BCT algorithms and check description not empty.
"""
for i in xrange(len(self.bct_adapters)):
for bct_identifier in self.bct_adapters[i].get_algorithms_dictionary():
### Prepare Operation and parameters
algorithm = dao.get_algorithm_by_group(self.algo_groups[i].id, bct_identifier)
self.assertTrue(len(algorithm.description) > 0,
"Description was not loaded properly for algorithm %s -- %s" % (str(algorithm),
bct_identifier))
def suite():
"""
