def test_project_disk_size(self):
project1 = TestFactory.create_project(self.test_user, 'test_proj1')
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_66.zip')
TestFactory.import_zip_connectivity(self.test_user, project1,
'testSubject', zip_path)
project2 = TestFactory.create_project(self.test_user, 'test_proj2')
TestFactory.import_cff(test_user=self.test_user, test_project=project2)
projects = self.project_service.retrieve_projects_for_user(
self.test_user.id)[0]
self.assertNotEqual(projects[0].disk_size, projects[1].disk_size,
"projects should have different size")
for project in projects:
self.assertNotEqual(0, project.disk_size)
self.assertNotEqual('0.0 KiB', project.disk_size_human)
prj_folder = self.structure_helper.get_project_folder(project)
actual_disk_size = self.compute_recursive_h5_disk_usage(
prj_folder)[0]
ratio = float(actual_disk_size) / project.disk_size
msg = "Real disk usage: %s The one recorded in the db : %s" % (
actual_disk_size, project.disk_size)
self.assertTrue(ratio < 1.4, msg)
def test_create_project_happy_flow(self):
"""
Standard flow for creating a new project.
"""
user1 = TestFactory.create_user('test_user1')
user2 = TestFactory.create_user('test_user2')
initial_projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(initial_projects), 0,
"Database reset probably failed!")
TestFactory.create_project(self.test_user,
'test_project',
users=[user1.id, user2.id])
resulting_projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(resulting_projects), 1,
"Project with valid data not inserted!")
project = resulting_projects[0]
if project.name == "test_project":
self.assertEqual(project.description, "description",
"Description do no match")
users_for_project = dao.get_members_of_project(project.id)
for user in users_for_project:
self.assertTrue(user.id in [user1.id, user2.id],
"Users not stored properly.")
self.assertTrue(
os.path.exists(
os.path.join(TvbProfile.current.TVB_STORAGE,
FilesHelper.PROJECTS_FOLDER, "test_project")),
"Folder for project was not created")
def test_remove_project_wrong_id(self):
"""
Flow for deleting a project giving an un-existing id.
"""
TestFactory.create_project(self.test_user, 'test_proj')
projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(projects), 1, "Initializations failed!")
self.assertRaises(ProjectServiceException, self.project_service.remove_project, 99)
def test_remove_project_wrong_id(self):
"""
Flow for deleting a project giving an un-existing id.
"""
TestFactory.create_project(self.test_user, 'test_proj')
projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(projects), 1, "Initializations failed!")
self.assertRaises(ProjectServiceException,
self.project_service.remove_project, 99)
def test_retrieve_projects_page2(self):
"""
Test for retrieving the second page projects for a given user.
"""
for i in range(PROJECTS_PAGE_SIZE + 3):
TestFactory.create_project(self.test_user, 'test_proj' + str(i))
projects, pages = self.project_service.retrieve_projects_for_user(self.test_user.id, 2)
self.assertEqual(len(projects), (PROJECTS_PAGE_SIZE + 3) % PROJECTS_PAGE_SIZE, "Pagination inproper.")
self.assertEqual(pages, 2, 'Wrong number of pages retrieved.')
def test_retrieve_projects_page2(self):
"""
Test for retrieving the second page projects for a given user.
"""
for i in range(PROJECTS_PAGE_SIZE + 3):
TestFactory.create_project(self.test_user, 'test_proj' + str(i))
projects, pages = self.project_service.retrieve_projects_for_user(
self.test_user.id, 2)
self.assertEqual(len(projects),
(PROJECTS_PAGE_SIZE + 3) % PROJECTS_PAGE_SIZE,
"Pagination inproper.")
self.assertEqual(pages, 2, 'Wrong number of pages retrieved.')
def test_viewall_valid_data(self):
"""
Create a bunch of projects and check that they are returned correctly.
"""
project1 = TestFactory.create_project(self.test_user, 'prj1')
TestFactory.create_project(self.test_user, 'prj2')
TestFactory.create_project(self.test_user, 'prj3')
result = self.project_c.viewall(selected_project_id=project1.id)
projects_list = result['projectsList']
## Use this old version of SET builder, otherwise it will fain on Python 2.6
self.assertEqual(set([prj.name for prj in projects_list]), {'prj1', 'prj2', 'prj3', 'Test'})
self.assertEqual(result['page_number'], 1)
self.assertEqual(result[common.KEY_PROJECT].name, 'prj1')
def test_viewall_valid_data(self):
"""
Create a bunch of projects and check that they are returned correctly.
"""
project1 = TestFactory.create_project(self.test_user, 'prj1')
TestFactory.create_project(self.test_user, 'prj2')
TestFactory.create_project(self.test_user, 'prj3')
result = self.project_c.viewall(selected_project_id=project1.id)
projects_list = result['projectsList']
## Use this old version of SET builder, otherwise it will fain on Python 2.6
self.assertEqual(set([prj.name for prj in projects_list]),
{'prj1', 'prj2', 'prj3', 'Test'})
self.assertEqual(result['page_number'], 1)
self.assertEqual(result[common.KEY_PROJECT].name, 'prj1')
def test_retrieve_1project_3usr(self):
"""
One user as admin, two users as members, getting projects for admin and for any of
the members should return one.
"""
member1 = TestFactory.create_user("member1")
member2 = TestFactory.create_user("member2")
TestFactory.create_project(self.test_user, 'Testproject', users=[member1.id, member2.id])
projects = self.project_service.retrieve_projects_for_user(self.test_user.id, 1)[0]
self.assertEqual(len(projects), 1, "Projects not retrieved properly!")
projects = self.project_service.retrieve_projects_for_user(member1.id, 1)[0]
self.assertEqual(len(projects), 1, "Projects not retrieved properly!")
projects = self.project_service.retrieve_projects_for_user(member2.id, 1)[0]
self.assertEqual(len(projects), 1, "Projects not retrieved properly!")
def test_get_linkable_projects(self):
"""
Test for retrieving the projects for a given user.
"""
initial_projects = self.project_service.retrieve_projects_for_user(self.test_user.id)[0]
self.assertEqual(len(initial_projects), 0, "Database was not reset!")
test_proj = []
user1 = TestFactory.create_user("another_user")
for i in range(4):
test_proj.append(TestFactory.create_project(self.test_user if i < 3 else user1, 'test_proj' + str(i)))
project_storage = self.structure_helper.get_project_folder(test_proj[0])
operation = TestFactory.create_operation(test_user=self.test_user, test_project=test_proj[0])
project_storage = os.path.join(project_storage, str(operation.id))
os.makedirs(project_storage)
datatype = dao.store_entity(model.DataType(module="test_data", subject="subj1",
state="test_state", operation_id=operation.id))
linkable = self.project_service.get_linkable_projects_for_user(self.test_user.id, str(datatype.id))[0]
self.assertEqual(len(linkable), 2, "Wrong count of link-able projects!")
proj_names = [project.name for project in linkable]
self.assertTrue(test_proj[1].name in proj_names)
self.assertTrue(test_proj[2].name in proj_names)
self.assertFalse(test_proj[3].name in proj_names)
def init(self, with_data=True, user_role="test"):
"""
Have a different name than setUp so we can use it safely in transactions and it will
not be called before running actual test.
Using setUp inheritance here won't WORK!! See TransactionalTest
"""
cherrypy.session = BaseControllersTest.CherrypySession()
if with_data:
# Add 3 entries so we no longer consider this the first run.
TvbProfile.current.manager.add_entries_to_config_file({
'test':
'test',
'test1':
'test1',
'test2':
'test2'
})
self.test_user = TestFactory.create_user(username="******",
role=user_role)
self.test_project = TestFactory.create_project(
self.test_user, "Test")
cherrypy.session[KEY_USER] = self.test_user
cherrypy.session[KEY_PROJECT] = self.test_project
def setUp(self):
"""
Set up the context needed by the tests.
"""
self.files_helper = FilesHelper()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user, self.PROJECT_NAME)
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 setUp(self):
"""
Reset the database before each test.
"""
self.test_user = TestFactory.create_user("UserPM")
self.test_project = TestFactory.create_project(self.test_user)
zip_path = os.path.join(os.path.dirname(tvb_data.sensors.__file__),
'eeg_brainstorm_65.txt')
TestFactory.import_sensors(self.test_user, self.test_project, zip_path,
Sensors_Importer.EEG_SENSORS)
zip_path = os.path.join(os.path.dirname(tvb_data.surfaceData.__file__),
'cortex_16384.zip')
TestFactory.import_surface_zip(self.test_user, self.test_project,
zip_path, CORTICAL, True)
self.surface = TestFactory.get_entity(self.test_project,
CorticalSurface())
self.assertTrue(self.surface is not None)
self.sensors = TestFactory.get_entity(self.test_project, SensorsEEG())
self.assertTrue(self.sensors is not None)
self.importer = TestFactory.create_adapter(
'tvb.adapters.uploaders.projection_matrix_importer',
'ProjectionMatrixSurfaceEEGImporter')
def setUp(self):
""" Prepare some entities to work with during tests:"""
self.flow_service = FlowService()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(admin=self.test_user)
### Insert some starting data in the database.
categ1 = model.AlgorithmCategory('one', True)
self.categ1 = dao.store_entity(categ1)
categ2 = model.AlgorithmCategory('two', rawinput=True)
self.categ2 = dao.store_entity(categ2)
group1 = model.AlgorithmGroup("test_module1", "classname1", categ1.id)
self.algo_group1 = dao.store_entity(group1)
group2 = model.AlgorithmGroup("test_module2", "classname2", categ2.id)
self.algo_group2 = dao.store_entity(group2)
group3 = model.AlgorithmGroup("test_module3", "classname3", categ1.id)
self.algo_group3 = dao.store_entity(group3)
group_v = model.AlgorithmGroup(TEST_ADAPTER_VALID_MODULE, TEST_ADAPTER_VALID_CLASS, categ2.id)
self.algo_group_v = dao.store_entity(group_v)
algo_v = model.Algorithm(self.algo_group_v.id, 'ident', name='', req_data='', param_name='', output='')
self.algorithm_v = dao.store_entity(algo_v)
algo1 = model.Algorithm(self.algo_group1.id, 'id', name='', req_data='', param_name='', output='')
self.algorithm1 = dao.store_entity(algo1)
def test_find_project_happy_flow(self):
"""
Standard flow for finding a project by it's id.
"""
initial_projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(initial_projects), 0,
"Database reset probably failed!")
inserted_project = TestFactory.create_project(self.test_user,
'test_project')
self.assertTrue(
self.project_service.find_project(inserted_project.id) is not None,
"Project not found !")
dao_returned_project = dao.get_project_by_id(inserted_project.id)
service_returned_project = self.project_service.find_project(
inserted_project.id)
self.assertEqual(
dao_returned_project.id, service_returned_project.id,
"Data returned from service is different from data returned by DAO."
)
self.assertEqual(
dao_returned_project.name, service_returned_project.name,
"Data returned from service is different than data returned by DAO."
)
self.assertEqual(
dao_returned_project.description,
service_returned_project.description,
"Data returned from service is different from data returned by DAO."
)
self.assertEqual(
dao_returned_project.members, service_returned_project.members,
"Data returned from service is different from data returned by DAO."
)
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 setUp(self):
"""
Reset the database before each test.
"""
self.test_user = TestFactory.create_user('CFF_User')
self.test_project = TestFactory.create_project(self.test_user,
"CFF_Project")
def test_get_linkable_projects(self):
"""
Test for retrieving the projects for a given user.
"""
initial_projects = self.project_service.retrieve_projects_for_user(
self.test_user.id)[0]
self.assertEqual(len(initial_projects), 0, "Database was not reset!")
test_proj = []
user1 = TestFactory.create_user("another_user")
for i in range(4):
test_proj.append(
TestFactory.create_project(self.test_user if i < 3 else user1,
'test_proj' + str(i)))
project_storage = self.structure_helper.get_project_folder(
test_proj[0])
operation = TestFactory.create_operation(test_user=self.test_user,
test_project=test_proj[0])
project_storage = os.path.join(project_storage, str(operation.id))
os.makedirs(project_storage)
datatype = dao.store_entity(
model.DataType(module="test_data",
subject="subj1",
state="test_state",
operation_id=operation.id))
linkable = self.project_service.get_linkable_projects_for_user(
self.test_user.id, str(datatype.id))[0]
self.assertEqual(len(linkable), 2,
"Wrong count of link-able projects!")
proj_names = [project.name for project in linkable]
self.assertTrue(test_proj[1].name in proj_names)
self.assertTrue(test_proj[2].name in proj_names)
self.assertFalse(test_proj[3].name in proj_names)
def test_retrieve_projects_and_del(self):
"""
Test for retrieving the second page projects for a given user.
"""
created_projects = []
for i in range(PROJECTS_PAGE_SIZE + 1):
created_projects.append(
TestFactory.create_project(self.test_user,
'test_proj' + str(i)))
projects, pages = self.project_service.retrieve_projects_for_user(
self.test_user.id, 2)
self.assertEqual(len(projects),
(PROJECTS_PAGE_SIZE + 1) % PROJECTS_PAGE_SIZE,
"Pagination improper.")
self.assertEqual(pages,
(PROJECTS_PAGE_SIZE + 1) / PROJECTS_PAGE_SIZE + 1,
'Wrong number of pages')
self.project_service.remove_project(created_projects[1].id)
projects, pages = self.project_service.retrieve_projects_for_user(
self.test_user.id, 2)
self.assertEqual(len(projects), 0, "Pagination improper.")
self.assertEqual(pages, 1, 'Wrong number of pages retrieved.')
projects, pages = self.project_service.retrieve_projects_for_user(
self.test_user.id, 1)
self.assertEqual(len(projects), PROJECTS_PAGE_SIZE,
"Pagination improper.")
self.assertEqual(pages, 1, 'Wrong number of pages retrieved.')
def setUp(self):
"""
Set up the context needed by the tests.
"""
self.files_helper = FilesHelper()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user,
self.PROJECT_NAME)
def setUp(self):
"""
Sets up the environment for running the tests;
creates a test user and a test project, saves old configuration and imports a CFF data-set
"""
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user)
TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project)
def setUp(self):
"""
Sets up the environment for running the tests;
creates a test user and a test project, saves old configuration and imports a CFF data-set
"""
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user)
TestFactory.import_cff(test_user=self.test_user,
test_project=self.test_project)
def setUp(self):
"""
Set up any additionally needed parameters.
"""
self.clean_database()
super(GenshiTestNDimensionArray, self).setUp()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user)
self.operation = TestFactory.create_operation(test_user=self.test_user, test_project=self.test_project)
def setUp(self):
"""
Reset the database before each test.
"""
self.clean_database()
self.flow_service = FlowService()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(admin=self.test_user)
self.operation = TestFactory.create_operation(test_user=self.test_user, test_project=self.test_project)
def test_create_project_happy_flow(self):
"""
Standard flow for creating a new project.
"""
user1 = TestFactory.create_user('test_user1')
user2 = TestFactory.create_user('test_user2')
initial_projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(initial_projects), 0, "Database reset probably failed!")
TestFactory.create_project(self.test_user, 'test_project', users=[user1.id, user2.id])
resulting_projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(resulting_projects), 1, "Project with valid data not inserted!")
project = resulting_projects[0]
if project.name == "test_project":
self.assertEqual(project.description, "description", "Description do no match")
users_for_project = dao.get_members_of_project(project.id)
for user in users_for_project:
self.assertTrue(user.id in [user1.id, user2.id], "Users not stored properly.")
self.assertTrue(os.path.exists(os.path.join(TvbProfile.current.TVB_STORAGE, FilesHelper.PROJECTS_FOLDER,
"test_project")), "Folder for project was not created")
def setUp(self):
""" Prepare some entities to work with during tests:"""
self.flow_service = FlowService()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(admin=self.test_user)
category = dao.get_uploader_categories()[0]
self.algorithm = dao.store_entity(model.Algorithm(TEST_ADAPTER_VALID_MODULE,
TEST_ADAPTER_VALID_CLASS, category.id))
def setUp(self):
"""
Reset the database before each test.
"""
self.clean_database()
initialize_storage()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user)
self.operation_service = OperationService()
self.backup_hdd_size = TvbProfile.current.MAX_DISK_SPACE
def setUp(self):
"""
Reset the database before each test.
"""
self.clean_database()
initialize_storage()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user)
self.operation_service = OperationService()
self.backup_hdd_size = TvbProfile.current.MAX_DISK_SPACE
def setUp(self):
"""
Reset the database before each test.
"""
self.clean_database()
self.flow_service = FlowService()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(admin=self.test_user)
self.operation = TestFactory.create_operation(
test_user=self.test_user, test_project=self.test_project)
def test_retrieve_1project_3usr(self):
"""
One user as admin, two users as members, getting projects for admin and for any of
the members should return one.
"""
member1 = TestFactory.create_user("member1")
member2 = TestFactory.create_user("member2")
TestFactory.create_project(self.test_user,
'Testproject',
users=[member1.id, member2.id])
projects = self.project_service.retrieve_projects_for_user(
self.test_user.id, 1)[0]
self.assertEqual(len(projects), 1, "Projects not retrieved properly!")
projects = self.project_service.retrieve_projects_for_user(
member1.id, 1)[0]
self.assertEqual(len(projects), 1, "Projects not retrieved properly!")
projects = self.project_service.retrieve_projects_for_user(
member2.id, 1)[0]
self.assertEqual(len(projects), 1, "Projects not retrieved properly!")
def setUp(self):
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_66.zip')
self.test_user = TestFactory.create_user('Test_User')
self.test_project = TestFactory.create_project(self.test_user,
"Test_Project")
TestFactory.import_zip_connectivity(self.test_user, self.test_project,
"John", zip_path)
self.connectivity = TestFactory.get_entity(self.test_project,
Connectivity())
def test_edit_project_unexisting(self):
"""
Trying to edit an un-existing project.
"""
selected_project = TestFactory.create_project(self.test_user, 'test_proj')
self.structure_helper.get_project_folder(selected_project)
initial_projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(initial_projects), 1, "Database initialization probably failed!")
data = dict(name="test_project", description="test_description", users=[])
self.assertRaises(ProjectServiceException, self.project_service.store_project,
self.test_user, False, 99, **data)
def setUp(self):
"""
Sets up the environment for running the tests;
cleans the database before testing and saves config file;
creates a test user, a test project;
creates burst, flow, operation and workflow services
"""
self.clean_database()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user)
def setUp(self):
"""
Sets up the environment for running the tests;
cleans the database before testing and saves config file;
creates a test user, a test project;
creates burst, flow, operation and workflow services
"""
self.clean_database()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user)
def setUp(self):
""" Prepare some entities to work with during tests:"""
self.flow_service = FlowService()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(admin=self.test_user)
category = dao.get_uploader_categories()[0]
self.algorithm = dao.store_entity(
model.Algorithm(TEST_ADAPTER_VALID_MODULE,
TEST_ADAPTER_VALID_CLASS, category.id))
def test_getmemberspage(self):
"""
Get the first page of the members page.
"""
users_count = dao.get_all_users(is_count=True)
user = TestFactory.create_user('usr', 'pass')
test_project = TestFactory.create_project(user, 'new_name')
result = self.project_c.getmemberspage(0, test_project.id)
self.assertEqual(result['usersMembers'], [])
# Same users as before should be available since we created new one
# as owned for the project.
self.assertEqual(len(result['usersList']), users_count)
def test_project_disk_size(self):
project1 = TestFactory.create_project(self.test_user, 'test_proj1')
zip_path = os.path.join(os.path.dirname(tvb_data.__file__), 'connectivity', 'connectivity_66.zip')
TestFactory.import_zip_connectivity(self.test_user, project1, 'testSubject', zip_path)
project2 = TestFactory.create_project(self.test_user, 'test_proj2')
TestFactory.import_cff(test_user=self.test_user, test_project=project2)
projects = self.project_service.retrieve_projects_for_user(self.test_user.id)[0]
self.assertNotEqual(projects[0].disk_size, projects[1].disk_size, "projects should have different size")
for project in projects:
self.assertNotEqual(0, project.disk_size)
self.assertNotEqual('0.0 KiB', project.disk_size_human)
prj_folder = self.structure_helper.get_project_folder(project)
actual_disk_size = self.compute_recursive_h5_disk_usage(prj_folder)[0]
ratio = float(actual_disk_size) / project.disk_size
msg = "Real disk usage: %s The one recorded in the db : %s" % (actual_disk_size, project.disk_size)
self.assertTrue(ratio < 1.4, msg)
def setUp(self):
_, self.connectivity = DatatypesFactory().create_connectivity()
self.test_user = TestFactory.create_user(username="******")
self.test_project = TestFactory.create_project(self.test_user, "Test")
burst_conf = BurstConfiguration(self.test_project.id)
burst_conf._simulator_configuration = self.CONF_HOPFIELD_HEUN_STOCH_RANGES
burst_conf.prepare_after_load()
burst_conf.simulator_configuration['connectivity'] = {'value': self.connectivity.gid}
self.s_manager = SerializationManager(burst_conf)
self.empty_manager = SerializationManager(BurstConfiguration(None))
def test_getmemberspage(self):
"""
Get the first page of the members page.
"""
users_count = dao.get_all_users(is_count=True)
user = TestFactory.create_user('usr', 'pass')
test_project = TestFactory.create_project(user, 'new_name')
result = self.project_c.getmemberspage(0, test_project.id)
self.assertEqual(result['usersMembers'], [])
# Same users as before should be available since we created new one
# as owned for the project.
self.assertEqual(len(result['usersList']), users_count)
def test_retrieve_3projects_3usr(self):
"""
Three users, 3 projects. Structure of db:
proj1: {admin: user1, members: [user2, user3]}
proj2: {admin: user2, members: [user1]}
proj3: {admin: user3, members: [user1, user2]}
Check valid project returns for all the users.
"""
member1 = TestFactory.create_user("member1")
member2 = TestFactory.create_user("member2")
member3 = TestFactory.create_user("member3")
TestFactory.create_project(member1,
'TestProject1',
users=[member2.id, member3.id])
TestFactory.create_project(member2, 'TestProject2', users=[member1.id])
TestFactory.create_project(member3,
'TestProject3',
users=[member1.id, member2.id])
projects = self.project_service.retrieve_projects_for_user(
member1.id, 1)[0]
self.assertEqual(len(projects), 3, "Projects not retrieved properly!")
projects = self.project_service.retrieve_projects_for_user(
member2.id, 1)[0]
self.assertEqual(len(projects), 3, "Projects not retrieved properly!")
projects = self.project_service.retrieve_projects_for_user(
member3.id, 1)[0]
self.assertEqual(len(projects), 2, "Projects not retrieved properly!")
def setUp(self):
"""
Sets up the testing environment;
saves config file;
creates a test user, a test project;
creates burst, operation, flow and workflow services
"""
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user)
self.workflow_service = WorkflowService()
self.burst_service = BurstService()
self.operation_service = OperationService()
self.flow_service = FlowService()
def _create_datatype_group(self):
"""
Creates a project, one DataTypeGroup with 2 DataTypes into the new group.
"""
test_project = TestFactory.create_project(self.test_user, "NewProject")
all_operations = dao.get_filtered_operations(test_project.id, None, is_count=True)
self.assertEqual(0, all_operations, "There should be no operation.")
datatypes, op_group_id = TestFactory.create_group(self.test_user, test_project)
dt_group = dao.get_datatypegroup_by_op_group_id(op_group_id)
return test_project, dt_group.id, datatypes[0], datatypes[1]
def setUp(self):
"""
Sets up the testing environment;
saves config file;
creates a test user, a test project;
creates burst, operation, flow and workflow services
"""
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user)
self.workflow_service = WorkflowService()
self.burst_service = BurstService()
self.operation_service = OperationService()
self.flow_service = FlowService()
def setUp(self):
"""
Prepare before each test.
"""
self.project_service = ProjectService()
self.flow_service = FlowService()
self.structure_helper = FilesHelper()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user, "ProjectStructure")
self.relevant_filter = StaticFiltersFactory.build_datatype_filters(single_filter=StaticFiltersFactory.RELEVANT_VIEW)
self.full_filter = StaticFiltersFactory.build_datatype_filters(single_filter=StaticFiltersFactory.FULL_VIEW)
def test_remove_project_happy_flow(self):
"""
Standard flow for deleting a project.
"""
inserted_project = TestFactory.create_project(self.test_user, 'test_proj')
project_root = self.structure_helper.get_project_folder(inserted_project)
projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(projects), 1, "Initializations failed!")
self.assertTrue(os.path.exists(project_root), "Something failed at insert time!")
self.project_service.remove_project(inserted_project.id)
projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(projects), 0, "Project was not deleted!")
self.assertFalse(os.path.exists(project_root), "Root folder not deleted!")
def test_retrieve_projects_for_user(self):
"""
Test for retrieving the projects for a given user. One page only.
"""
initial_projects = self.project_service.retrieve_projects_for_user(self.test_user.id)[0]
self.assertEqual(len(initial_projects), 0, "Database was not reset properly!")
TestFactory.create_project(self.test_user, 'test_proj')
TestFactory.create_project(self.test_user, 'test_proj1')
TestFactory.create_project(self.test_user, 'test_proj2')
user1 = TestFactory.create_user('another_user')
TestFactory.create_project(user1, 'test_proj3')
projects = self.project_service.retrieve_projects_for_user(self.test_user.id)[0]
self.assertEqual(len(projects), 3, "Projects not retrieved properly!")
for project in projects:
self.assertNotEquals(project.name, "test_project3", "This project should not have been retrieved")
def setUp(self):
"""
Reset the database before each test.
"""
self.import_service = ImportService()
self.flow_service = FlowService()
self.project_service = ProjectService()
self.test_user = TestFactory.create_user()
self.test_project = TestFactory.create_project(self.test_user, name="GeneratedProject", description="test_desc")
self.operation = TestFactory.create_operation(test_user=self.test_user, test_project=self.test_project)
self.adapter_instance = TestFactory.create_adapter(test_project=self.test_project)
TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project)
self.zip_path = None
def test_edit_project_happy_flow(self):
"""
Standard flow for editing an existing project.
"""
selected_project = TestFactory.create_project(self.test_user, 'test_proj')
proj_root = self.structure_helper.get_project_folder(selected_project)
initial_projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(initial_projects), 1, "Database initialization probably failed!")
edited_data = dict(name="test_project", description="test_description", users=[])
edited_project = self.project_service.store_project(self.test_user, False, selected_project.id, **edited_data)
self.assertFalse(os.path.exists(proj_root), "Previous folder not deleted")
proj_root = self.structure_helper.get_project_folder(edited_project)
self.assertTrue(os.path.exists(proj_root), "New folder not created!")
self.assertNotEqual(selected_project.name, edited_project.name, "Project was no changed!")
def test_edit_project_unexisting(self):
"""
Trying to edit an un-existing project.
"""
selected_project = TestFactory.create_project(self.test_user,
'test_proj')
self.structure_helper.get_project_folder(selected_project)
initial_projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(initial_projects), 1,
"Database initialization probably failed!")
data = dict(name="test_project",
description="test_description",
users=[])
self.assertRaises(ProjectServiceException,
self.project_service.store_project, self.test_user,
False, 99, **data)
def test_retrieve_projects_and_del(self):
"""
Test for retrieving the second page projects for a given user.
"""
created_projects = []
for i in range(PROJECTS_PAGE_SIZE + 1):
created_projects.append(TestFactory.create_project(self.test_user, 'test_proj' + str(i)))
projects, pages = self.project_service.retrieve_projects_for_user(self.test_user.id, 2)
self.assertEqual(len(projects), (PROJECTS_PAGE_SIZE + 1) % PROJECTS_PAGE_SIZE, "Pagination improper.")
self.assertEqual(pages, (PROJECTS_PAGE_SIZE + 1) / PROJECTS_PAGE_SIZE + 1, 'Wrong number of pages')
self.project_service.remove_project(created_projects[1].id)
projects, pages = self.project_service.retrieve_projects_for_user(self.test_user.id, 2)
self.assertEqual(len(projects), 0, "Pagination improper.")
self.assertEqual(pages, 1, 'Wrong number of pages retrieved.')
projects, pages = self.project_service.retrieve_projects_for_user(self.test_user.id, 1)
self.assertEqual(len(projects), PROJECTS_PAGE_SIZE, "Pagination improper.")
self.assertEqual(pages, 1, 'Wrong number of pages retrieved.')
def setUp(self):
"""
Reset the database before each test.
"""
self.test_user = TestFactory.create_user("UserPM")
self.test_project = TestFactory.create_project(self.test_user)
zip_path = os.path.join(os.path.dirname(tvb_data.sensors.__file__), "eeg_brainstorm_65.txt")
TestFactory.import_sensors(self.test_user, self.test_project, zip_path, Sensors_Importer.EEG_SENSORS)
zip_path = os.path.join(os.path.dirname(tvb_data.surfaceData.__file__), "cortex_16384.zip")
TestFactory.import_surface_zip(self.test_user, self.test_project, zip_path, CORTICAL, True)
self.surface = TestFactory.get_entity(self.test_project, CorticalSurface())
self.assertTrue(self.surface is not None)
self.sensors = TestFactory.get_entity(self.test_project, SensorsEEG())
self.assertTrue(self.sensors is not None)
def test_remove_project_happy_flow(self):
"""
Standard flow for deleting a project.
"""
inserted_project = TestFactory.create_project(self.test_user,
'test_proj')
project_root = self.structure_helper.get_project_folder(
inserted_project)
projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(projects), 1, "Initializations failed!")
self.assertTrue(os.path.exists(project_root),
"Something failed at insert time!")
self.project_service.remove_project(inserted_project.id)
projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(projects), 0, "Project was not deleted!")
self.assertFalse(os.path.exists(project_root),
"Root folder not deleted!")
def init(self, with_data=True, user_role="test"):
"""
Have a different name than setUp so we can use it safely in transactions and it will
not be called before running actual test.
Using setUp inheritance here won't WORK!! See TransactionalTest
"""
cherrypy.session = BaseControllersTest.CherrypySession()
if with_data:
# Add 3 entries so we no longer consider this the first run.
TvbProfile.current.manager.add_entries_to_config_file({'test': 'test',
'test1': 'test1',
'test2': 'test2'})
self.test_user = TestFactory.create_user(username="******", role=user_role)
self.test_project = TestFactory.create_project(self.test_user, "Test")
cherrypy.session[KEY_USER] = self.test_user
cherrypy.session[KEY_PROJECT] = self.test_project
def test_find_project_happy_flow(self):
"""
Standard flow for finding a project by it's id.
"""
initial_projects = dao.get_projects_for_user(self.test_user.id)
self.assertEqual(len(initial_projects), 0, "Database reset probably failed!")
inserted_project = TestFactory.create_project(self.test_user, 'test_project')
self.assertTrue(self.project_service.find_project(inserted_project.id) is not None, "Project not found !")
dao_returned_project = dao.get_project_by_id(inserted_project.id)
service_returned_project = self.project_service.find_project(inserted_project.id)
self.assertEqual(dao_returned_project.id, service_returned_project.id,
"Data returned from service is different from data returned by DAO.")
self.assertEqual(dao_returned_project.name, service_returned_project.name,
"Data returned from service is different than data returned by DAO.")
self.assertEqual(dao_returned_project.description, service_returned_project.description,
"Data returned from service is different from data returned by DAO.")
self.assertEqual(dao_returned_project.members, service_returned_project.members,
"Data returned from service is different from data returned by DAO.")
def setUpTVB(self):
"""
Creates a user, an algorithm and 2 projects
Project src_project will have an operation and 2 datatypes
Project dest_project will be empty.
Initializes a flow and a project service
"""
datatype_factory = DatatypesFactory()
self.user = datatype_factory.user
self.src_project = datatype_factory.project
self.red_datatype = datatype_factory.create_simple_datatype(subject=self.GEORGE1st)
self.blue_datatype = datatype_factory.create_datatype_with_storage(subject=self.GEORGE2nd)
# create the destination project
self.dest_project = TestFactory.create_project(admin=datatype_factory.user, name="destination")
self.flow_service = FlowService()
self.project_service = ProjectService()
