class TestDatatypeResource(RestResourceTest):
def transactional_setup_method(self):
self.test_user = TestFactory.create_user('Rest_User')
self.test_project = TestFactory.create_project(
self.test_user, 'Rest_Project', users=[self.test_user.id])
self.retrieve_resource = RetrieveDatatypeResource()
self.get_operations_resource = GetOperationsForDatatypeResource()
self.get_data_in_project_resource = GetDataInProjectResource()
def test_server_retrieve_datatype_inexistent_gid(self, mocker):
self._mock_user(mocker)
datatype_gid = "inexistent-gid"
with pytest.raises(InvalidIdentifierException):
self.retrieve_resource.get(datatype_gid=datatype_gid)
def test_server_retrieve_datatype(self, mocker):
self._mock_user(mocker)
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_96.zip')
TestFactory.import_zip_connectivity(self.test_user, self.test_project,
zip_path)
datatypes_in_project = self.get_data_in_project_resource.get(
project_gid=self.test_project.gid)
assert type(datatypes_in_project) is list
assert len(datatypes_in_project) == 1
assert datatypes_in_project[0].type == ConnectivityIndex().display_type
def send_file_dummy(path, as_attachment, attachment_filename):
return (path, as_attachment, attachment_filename)
# Mock flask.send_file to behave like send_file_dummy
mocker.patch('flask.send_file', send_file_dummy)
result = self.retrieve_resource.get(
datatype_gid=datatypes_in_project[0].gid)
assert type(result) is tuple
assert result[1] is True
assert os.path.basename(result[0]) == os.path.basename(result[2])
@pytest.mark.skipif(no_matlab(), reason="Matlab or Octave not installed!")
def test_server_get_operations_for_datatype(self, mocker):
self._mock_user(mocker)
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_96.zip')
TestFactory.import_zip_connectivity(self.test_user, self.test_project,
zip_path)
datatypes_in_project = self.get_data_in_project_resource.get(
project_gid=self.test_project.gid)
assert type(datatypes_in_project) is list
assert len(datatypes_in_project) == 1
assert datatypes_in_project[0].type == ConnectivityIndex().display_type
result = self.get_operations_resource.get(
datatype_gid=datatypes_in_project[0].gid)
assert type(result) is list
assert len(result) > 3
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(no_matlab(), 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(no_matlab(), reason="Matlab or Octave not installed!")
def test_bct_all(self):
"""
Iterate all BCT algorithms and execute them.
"""
view_model = BaseBCTModel()
view_model.connectivity = self.connectivity.gid
algo_category = dao.get_category_by_id(
self.bct_adapters[0].stored_adapter.fk_category)
for adapter_instance in self.bct_adapters:
results = TestFactory.launch_synchronously(self.test_user.id,
self.test_project,
adapter_instance,
view_model)
assert len(results) > 0
@pytest.mark.skipif(no_matlab(), 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 TestProjectStructure(TransactionalTestCase):
"""
Test ProjectService methods (part related to Project Data Structure).
"""
def transactional_setup_method(self):
"""
Prepare before each test.
"""
self.project_service = ProjectService()
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 transactional_teardown_method(self):
"""
Clear project folders after testing
"""
self.delete_project_folders()
def test_set_operation_visibility(self):
"""
Check if the visibility for an operation is set correct.
"""
self.__init_algorithmn()
op1 = Operation(None, self.test_user.id, self.test_project.id,
self.algo_inst.id)
op1 = dao.store_entity(op1)
assert op1.visible, "The operation should be visible."
self.project_service.set_operation_and_group_visibility(op1.gid, False)
updated_op = dao.get_operation_by_id(op1.id)
assert not updated_op.visible, "The operation should not be visible."
def test_set_op_and_group_visibility(self, datatype_group_factory):
"""
When changing the visibility for an operation that belongs to an operation group, we
should also change the visibility for the entire group of operations.
"""
group = datatype_group_factory()
list_of_operations = dao.get_operations_in_group(group.id)
for operation in list_of_operations:
assert operation.visible, "The operation should be visible."
self.project_service.set_operation_and_group_visibility(
list_of_operations[0].gid, False)
operations = dao.get_operations_in_group(group.id)
for operation in operations:
assert not operation.visible, "The operation should not be visible."
def test_set_op_group_visibility(self, datatype_group_factory):
"""
Tests if the visibility for an operation group is set correct.
"""
group = datatype_group_factory()
list_of_operations = dao.get_operations_in_group(group.id)
for operation in list_of_operations:
assert operation.visible, "The operation should be visible."
op_group = dao.get_operationgroup_by_id(group.id)
self.project_service.set_operation_and_group_visibility(
op_group.gid, False, True)
operations = dao.get_operations_in_group(group.id)
for operation in operations:
assert not operation.visible, "The operation should not be visible."
def test_is_upload_operation(self):
"""
Tests that upload and non-upload algorithms are created and run accordingly
"""
self.__init_algorithmn()
upload_algo = self._create_algo_for_upload()
op1 = Operation(None, self.test_user.id, self.test_project.id,
self.algo_inst.id)
op2 = Operation(None, self.test_user.id, self.test_project.id,
upload_algo.id)
operations = dao.store_entities([op1, op2])
is_upload_operation = self.project_service.is_upload_operation(
operations[0].gid)
assert not is_upload_operation, "The operation is not an upload operation."
is_upload_operation = self.project_service.is_upload_operation(
operations[1].gid)
assert is_upload_operation, "The operation is an upload operation."
def test_get_upload_operations(self):
"""
Test get_all when filter is for Upload category.
"""
self.__init_algorithmn()
upload_algo = self._create_algo_for_upload()
project = Project("test_proj_2", self.test_user.id, "desc")
project = dao.store_entity(project)
op1 = Operation(None, self.test_user.id, self.test_project.id,
self.algo_inst.id)
op2 = Operation(None,
self.test_user.id,
project.id,
upload_algo.id,
status=STATUS_FINISHED)
op3 = Operation(None, self.test_user.id, self.test_project.id,
upload_algo.id)
op4 = Operation(None,
self.test_user.id,
self.test_project.id,
upload_algo.id,
status=STATUS_FINISHED)
op5 = Operation(None,
self.test_user.id,
self.test_project.id,
upload_algo.id,
status=STATUS_FINISHED)
operations = dao.store_entities([op1, op2, op3, op4, op5])
upload_operations = self.project_service.get_all_operations_for_uploaders(
self.test_project.id)
assert 2 == len(
upload_operations), "Wrong number of upload operations."
upload_ids = [operation.id for operation in upload_operations]
for i in [3, 4]:
assert operations[i].id in upload_ids, \
"The operation should be an upload operation."
for i in [0, 1, 2]:
assert not operations[i].id in upload_ids, \
"The operation should not be an upload operation."
def test_is_datatype_group(self, datatype_group_factory):
"""
Tests if a datatype is group.
"""
group = datatype_group_factory()
dt_group = dao.get_generic_entity(DataTypeGroup, group.id)[0]
is_dt_group = self.project_service.is_datatype_group(dt_group.gid)
assert is_dt_group, "The datatype should be a datatype group."
datatypes = dao.get_datatypes_from_datatype_group(dt_group.id)
is_dt_group = self.project_service.is_datatype_group(datatypes[0].gid)
assert not is_dt_group, "The datatype should not be a datatype group."
def test_count_datatypes_in_group(self, datatype_group_factory):
""" Test that counting dataTypes is correct. Happy flow."""
group = datatype_group_factory()
count = dao.count_datatypes_in_group(group.id)
assert count == group.count_results
assert count == 6
datatypes = dao.get_datatypes_from_datatype_group(group.id)
count = dao.count_datatypes_in_group(datatypes[0].id)
assert count == 0, "There should be no dataType."
def test_set_datatype_visibility(self, dummy_datatype_index_factory):
"""
Check if the visibility for a datatype is set correct.
"""
# it's a list of 3 elem.
dummy_dt_index = dummy_datatype_index_factory()
is_visible = dummy_dt_index.visible
assert is_visible, "The data type should be visible."
self.project_service.set_datatype_visibility(dummy_dt_index.gid, False)
is_visible = dao.get_datatype_by_id(dummy_dt_index.id).visible
assert not is_visible, "The data type should not be visible."
def test_set_visibility_for_dt_in_group(self, datatype_group_factory):
"""
Check if the visibility for a datatype from a datatype group is set correct.
"""
group = datatype_group_factory()
datatypes = dao.get_datatypes_from_datatype_group(group.id)
assert datatypes[0].visible, "The data type should be visible."
assert datatypes[1].visible, "The data type should be visible."
self.project_service.set_datatype_visibility(datatypes[0].gid, False)
db_dt_group = self.project_service.get_datatype_by_id(group.id)
db_first_dt = self.project_service.get_datatype_by_id(datatypes[0].id)
db_second_dt = self.project_service.get_datatype_by_id(datatypes[1].id)
assert not db_dt_group.visible, "The data type should be visible."
assert not db_first_dt.visible, "The data type should not be visible."
assert not db_second_dt.visible, "The data type should be visible."
def test_set_visibility_for_group(self, datatype_group_factory):
"""
Check if the visibility for a datatype group is set correct.
"""
group = datatype_group_factory()
dt_group = dao.get_generic_entity(DataTypeGroup, group.id)[0]
datatypes = dao.get_datatypes_from_datatype_group(dt_group.id)
assert dt_group.visible, "The data type group should be visible."
assert datatypes[0].visible, "The data type should be visible."
assert datatypes[1].visible, "The data type should be visible."
self.project_service.set_datatype_visibility(dt_group.gid, False)
updated_dt_group = self.project_service.get_datatype_by_id(dt_group.id)
updated_first_dt = self.project_service.get_datatype_by_id(
datatypes[0].id)
updated_second_dt = self.project_service.get_datatype_by_id(
datatypes[1].id)
assert not updated_dt_group.visible, "The data type group should be visible."
assert not updated_first_dt.visible, "The data type should be visible."
assert not updated_second_dt.visible, "The data type should be visible."
def test_getdatatypes_from_dtgroup(self, datatype_group_factory):
"""
Validate that we can retrieve all DTs from a DT_Group
"""
group = datatype_group_factory()
exp_datatypes = dao.get_datatypes_from_datatype_group(group.id)
datatypes = self.project_service.get_datatypes_from_datatype_group(
group.id)
assert len(
datatypes
) == group.count_results, "There should be 10 datatypes into the datatype group."
expected_dict = {
exp_datatypes[0].id: exp_datatypes[0],
exp_datatypes[1].id: exp_datatypes[1]
}
actual_dict = {
datatypes[0].id: datatypes[0],
datatypes[1].id: datatypes[1]
}
for key in expected_dict:
expected = expected_dict[key]
actual = actual_dict[key]
assert expected.id == actual.id, "Not the same id."
assert expected.gid == actual.gid, "Not the same gid."
assert expected.type == actual.type, "Not the same type."
assert expected.subject == actual.subject, "Not the same subject."
assert expected.state == actual.state, "Not the same state."
assert expected.visible == actual.visible, "The datatype visibility is not correct."
assert expected.module == actual.module, "Not the same module."
assert expected.user_tag_1 == actual.user_tag_1, "Not the same user_tag_1."
assert expected.invalid == actual.invalid, "The invalid field value is not correct."
assert expected.is_nan == actual.is_nan, "The is_nan field value is not correct."
@pytest.mark.skipif(no_matlab(), reason="Matlab or Octave not installed!")
def test_get_inputs_for_operation(self):
"""
Tests method get_datatype_and_datatypegroup_inputs_for_operation.
Verifies filters' influence over results is as expected
"""
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_66.zip')
conn = TestFactory.import_zip_connectivity(self.test_user,
self.test_project, zip_path)
view_model = BaseBCTModel()
view_model.connectivity = conn.gid
adapter = ABCAdapter.build_adapter_from_class(
TransitivityBinaryDirected)
result = OperationService().fire_operation(adapter,
self.test_user,
self.test_project.id,
view_model=view_model)
conn.visible = False
dao.store_entity(conn)
operation = dao.get_operation_by_id(result[0].id)
inputs = self.project_service.get_datatype_and_datatypegroup_inputs_for_operation(
operation.gid, self.relevant_filter)
assert len(inputs) == 0
inputs = self.project_service.get_datatype_and_datatypegroup_inputs_for_operation(
operation.gid, self.full_filter)
assert len(inputs) == 1, "Incorrect number of inputs."
assert conn.id == inputs[0].id, "Retrieved wrong input dataType."
def test_remove_datatype(self, array_factory):
"""
Tests the deletion of a datatype.
"""
# it's a list of 3 elem.
array_wrappers = array_factory(self.test_project)
dt_list = []
for array_wrapper in array_wrappers:
dt_list.append(dao.get_datatype_by_id(array_wrapper[0]))
self.project_service.remove_datatype(self.test_project.id,
dt_list[0].gid)
self._check_if_datatype_was_removed(dt_list[0])
def test_remove_datatype_from_group(self, datatype_group_factory,
project_factory, user_factory):
"""
Tests the deletion of a datatype group.
"""
user = user_factory()
project = project_factory(user)
group = datatype_group_factory(project=project)
datatype_group = dao.get_generic_entity(DataTypeGroup, group.id)[0]
datatypes = dao.get_datatypes_from_datatype_group(group.id)
datatype_measure = dao.get_generic_entity(DatatypeMeasureIndex,
datatypes[0].gid,
"fk_source_gid")[0]
# When trying to delete one entity in a group the entire group will be removed
# First remove the DTMeasures, to avoid FK failures
self.project_service.remove_datatype(project.id, datatype_measure.gid)
self.project_service.remove_datatype(project.id, datatypes[0].gid)
self._check_if_datatype_was_removed(datatypes[0])
self._check_if_datatype_was_removed(datatypes[1])
self._check_if_datatype_was_removed(datatype_group)
self._check_if_datatype_was_removed(datatype_measure)
self._check_datatype_group_removed(group.id,
datatype_group.fk_operation_group)
def test_remove_datatype_group(self, datatype_group_factory,
project_factory, user_factory):
"""
Tests the deletion of a datatype group.
"""
user = user_factory()
project = project_factory(user)
group = datatype_group_factory(project=project)
datatype_groups = self.get_all_entities(DataTypeGroup)
datatypes = dao.get_datatypes_from_datatype_group(group.id)
assert 2 == len(datatype_groups)
self.project_service.remove_datatype(project.id,
datatype_groups[1].gid)
self.project_service.remove_datatype(project.id,
datatype_groups[0].gid)
self._check_if_datatype_was_removed(datatypes[0])
self._check_if_datatype_was_removed(datatypes[1])
self._check_if_datatype_was_removed(datatype_groups[0])
self._check_if_datatype_was_removed(datatype_groups[1])
self._check_datatype_group_removed(
group.id, datatype_groups[0].fk_operation_group)
@pytest.fixture()
def array_factory(self, operation_factory, connectivity_index_factory):
def _create_measure(conn, op, op_dir, project_id):
conn_measure = ConnectivityMeasure()
conn_measure.connectivity = h5.load_from_index(conn)
conn_measure.array_data = numpy.array(conn.number_of_regions)
conn_measure_db = h5.store_complete(conn_measure, op_dir)
conn_measure_db.fk_from_operation = op.id
dao.store_entity(conn_measure_db)
count = dao.count_datatypes(project_id, DataTypeMatrix)
return count
def build(project):
count = dao.count_datatypes(project.id, DataTypeMatrix)
assert count == 0
op = operation_factory(test_project=project)
conn = connectivity_index_factory(op=op)
storage_path = FilesHelper().get_project_folder(
op.project, str(op.id))
count = _create_measure(conn, op, storage_path, project.id)
assert count == 1
count = _create_measure(conn, op, storage_path, project.id)
assert count == 2
count = _create_measure(conn, op, storage_path, project.id)
assert count == 3
return get_filtered_datatypes(project.id, DataTypeMatrix)[0]
return build
def _check_if_datatype_was_removed(self, datatype):
"""
Check if a certain datatype was removed.
"""
try:
dao.get_datatype_by_id(datatype.id)
raise AssertionError("The datatype was not deleted.")
except Exception:
pass
try:
dao.get_operation_by_id(datatype.fk_from_operation)
raise AssertionError("The operation was not deleted.")
except Exception:
pass
def _check_datatype_group_removed(self, datatype_group_id,
operation_groupp_id):
"""
Checks if the DataTypeGroup and OperationGroup was removed.
"""
try:
dao.get_generic_entity(DataTypeGroup, datatype_group_id)
raise AssertionError("The DataTypeGroup entity was not removed.")
except Exception:
pass
try:
dao.get_operationgroup_by_id(operation_groupp_id)
raise AssertionError("The OperationGroup entity was not removed.")
except Exception:
pass
def __init_algorithmn(self):
"""
Insert some starting data in the database.
"""
categ1 = AlgorithmCategory('one', True)
self.categ1 = dao.store_entity(categ1)
ad = Algorithm(TEST_ADAPTER_VALID_MODULE, TEST_ADAPTER_VALID_CLASS,
categ1.id)
self.algo_inst = dao.store_entity(ad)
@staticmethod
def _create_algo_for_upload():
""" Creates a fake algorithm for an upload category. """
category = dao.store_entity(
AlgorithmCategory("upload_category", rawinput=True))
return dao.store_entity(Algorithm("module", "classname", category.id))
class TestImportService(BaseTestCase):
"""
This class contains tests for the tvb.core.services.import_service module.
"""
def setup_method(self):
"""
Reset the database before each test.
"""
self.import_service = ImportService()
self.project_service = ProjectService()
self.zip_path = None
def teardown_method(self):
"""
Reset the database when test is done.
"""
# Delete TEMP folder
if os.path.exists(TvbProfile.current.TVB_TEMP_FOLDER):
shutil.rmtree(TvbProfile.current.TVB_TEMP_FOLDER)
# Delete folder where data was exported
if self.zip_path and os.path.exists(self.zip_path):
shutil.rmtree(os.path.split(self.zip_path)[0])
self.delete_project_folders()
@pytest.mark.skipif(no_matlab(), reason="Matlab or Octave not installed!")
def test_import_export(self, user_factory, project_factory,
value_wrapper_factory):
"""
Test the import/export mechanism for a project structure.
The project contains the following data types: Connectivity, Surface, MappedArray and ValueWrapper.
"""
test_user = user_factory()
test_project = project_factory(test_user, "TestImportExport",
"test_desc")
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_66.zip')
TestFactory.import_zip_connectivity(test_user, test_project, zip_path)
value_wrapper = value_wrapper_factory(test_user, test_project)
ProjectService.set_datatype_visibility(value_wrapper.gid, False)
result = self.get_all_datatypes()
expected_results = {}
for one_data in result:
expected_results[one_data.gid] = (one_data.module, one_data.type)
# Export project as ZIP
self.zip_path = ExportManager().export_project(test_project)
assert self.zip_path is not None, "Exported file is none"
# Remove the original project
self.project_service.remove_project(test_project.id)
result, lng_ = self.project_service.retrieve_projects_for_user(
test_user.id)
assert 0 == len(result), "Project Not removed!"
assert 0 == lng_, "Project Not removed!"
# Now try to import again project
self.import_service.import_project_structure(self.zip_path,
test_user.id)
result = self.project_service.retrieve_projects_for_user(
test_user.id)[0]
assert len(result) == 1, "There should be only one project."
assert result[
0].name == "TestImportExport", "The project name is not correct."
assert result[
0].description == "test_desc", "The project description is not correct."
test_project = result[0]
count_operations = dao.get_filtered_operations(test_project.id,
None,
is_count=True)
# 1 op. - import conn; 2 op. - BCT Analyzer
assert 2 == count_operations, "Invalid ops number after export and import !"
for gid in expected_results:
datatype = dao.get_datatype_by_gid(gid)
assert datatype.module == expected_results[gid][
0], 'DataTypes not imported correctly'
assert datatype.type == expected_results[gid][
1], 'DataTypes not imported correctly'
# check the value wrapper
new_val = try_get_last_datatype(test_project.id, ValueWrapperIndex)
assert value_wrapper.data_value == new_val.data_value, "Data value incorrect"
assert value_wrapper.data_type == new_val.data_type, "Data type incorrect"
assert value_wrapper.data_name == new_val.data_name, "Data name incorrect"
assert False == new_val.visible, "Visibility incorrectly restored"
def test_import_export_existing(self, user_factory, project_factory):
"""
Test the import/export mechanism for a project structure.
The project contains the following data types: Connectivity, Surface, MappedArray and ValueWrapper.
"""
test_user = user_factory()
test_project = project_factory(test_user, "TestImportExport2")
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_66.zip')
TestFactory.import_zip_connectivity(test_user, test_project, zip_path)
count_operations = dao.get_filtered_operations(test_project.id,
None,
is_count=True)
assert 1 == count_operations, "Invalid ops before export!"
self.zip_path = ExportManager().export_project(test_project)
assert self.zip_path is not None, "Exported file is none"
with pytest.raises(ImportException):
self.import_service.import_project_structure(
self.zip_path, test_user.id)
def test_export_import_burst(self, user_factory, project_factory,
simulation_launch):
"""
Test that fk_parent_burst is correctly preserved after export/import
"""
test_user = user_factory()
test_project = project_factory(test_user, "TestIESim")
sim_op = simulation_launch(test_user,
test_project,
simulation_length=10)
tries = 5
while not sim_op.has_finished and tries > 0:
sleep(5)
tries = tries - 1
sim_op = dao.get_operation_by_id(sim_op.id)
assert sim_op.has_finished, "Simulation did not finish in the given time"
self.zip_path = ExportManager().export_project(test_project)
assert self.zip_path is not None, "Exported file is none"
self.project_service.remove_project(test_project.id)
self.import_service.import_project_structure(self.zip_path,
test_user.id)
retrieved_project = self.project_service.retrieve_projects_for_user(
test_user.id)[0][0]
ts = try_get_last_datatype(retrieved_project.id, TimeSeriesRegionIndex)
bursts = dao.get_bursts_for_project(retrieved_project.id)
assert 1 == len(bursts)
assert ts.fk_parent_burst == bursts[0].gid
def test_export_import_figures(self, user_factory, project_factory):
"""
Test that ResultFigure instances are correctly restores after an export+import project
"""
# Prepare data
user = user_factory()
project = project_factory(user, "TestImportExportFigures")
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'paupau.zip')
TestFactory.import_zip_connectivity(user, project, zip_path)
figure_service = FigureService()
figure_service.store_result_figure(project, user, "png", IMG_DATA,
"bla")
figure_service.store_result_figure(project, user, "png", IMG_DATA,
"bla")
figures = list(
figure_service.retrieve_result_figures(project,
user)[0].values())[0]
assert 2 == len(figures)
# export, delete and the import project
self.zip_path = ExportManager().export_project(project)
assert self.zip_path is not None, "Exported file is none"
self.project_service.remove_project(project.id)
self.import_service.import_project_structure(self.zip_path, user.id)
# Check that state is as before export: one operation, one DT, 2 figures
retrieved_project = self.project_service.retrieve_projects_for_user(
user.id)[0][0]
count_operations = dao.get_filtered_operations(retrieved_project.id,
None,
is_count=True)
assert 1 == count_operations
count_datatypes = dao.count_datatypes(retrieved_project.id, DataType)
assert 1 == count_datatypes
figures = list(
figure_service.retrieve_result_figures(retrieved_project,
user)[0].values())[0]
assert 2 == len(figures)
assert "bla" in figures[0].name
assert "bla" in figures[1].name
image_path = utils.url2path(figures[0].file_path)
img_data = Image.open(image_path).load()
assert img_data is not None
class TestImportService(BaseTestCase):
"""
This class contains tests for the tvb.core.services.import_service module.
"""
def setup_method(self):
"""
Reset the database before each test.
"""
self.import_service = ImportService()
self.project_service = ProjectService()
self.zip_path = None
def teardown_method(self):
"""
Reset the database when test is done.
"""
# Delete TEMP folder
if os.path.exists(TvbProfile.current.TVB_TEMP_FOLDER):
shutil.rmtree(TvbProfile.current.TVB_TEMP_FOLDER)
# Delete folder where data was exported
if self.zip_path and os.path.exists(self.zip_path):
shutil.rmtree(os.path.split(self.zip_path)[0])
self.delete_project_folders()
@pytest.mark.skipif(no_matlab(), reason="Matlab or Octave not installed!")
def test_import_export(self, user_factory, project_factory,
value_wrapper_factory):
"""
Test the import/export mechanism for a project structure.
The project contains the following data types: Connectivity, Surface, MappedArray and ValueWrapper.
"""
test_user = user_factory()
test_project = project_factory(test_user, "TestImportExport",
"test_desc")
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_66.zip')
TestFactory.import_zip_connectivity(test_user, test_project, zip_path)
value_wrapper = value_wrapper_factory(test_user, test_project)
result = self.get_all_datatypes()
expected_results = {}
for one_data in result:
expected_results[one_data.gid] = (one_data.module, one_data.type)
# Export project as ZIP
self.zip_path = ExportManager().export_project(test_project)
assert self.zip_path is not None, "Exported file is none"
# Remove the original project
self.project_service.remove_project(test_project.id)
result, lng_ = self.project_service.retrieve_projects_for_user(
test_user.id)
assert 0 == len(result), "Project Not removed!"
assert 0 == lng_, "Project Not removed!"
# Now try to import again project
self.import_service.import_project_structure(self.zip_path,
test_user.id)
result = self.project_service.retrieve_projects_for_user(
test_user.id)[0]
assert len(result) == 1, "There should be only one project."
assert result[
0].name == "TestImportExport", "The project name is not correct."
assert result[
0].description == "test_desc", "The project description is not correct."
test_project = result[0]
count_operations = dao.get_filtered_operations(test_project.id,
None,
is_count=True)
# 1 op. - import conn; 2 op. - BCT Analyzer
assert 2 == count_operations, "Invalid ops number after export and import !"
for gid in expected_results:
datatype = dao.get_datatype_by_gid(gid)
assert datatype.module == expected_results[gid][
0], 'DataTypes not imported correctly'
assert datatype.type == expected_results[gid][
1], 'DataTypes not imported correctly'
# check the value wrapper
new_val = try_get_last_datatype(test_project.id, ValueWrapperIndex)
assert value_wrapper.data_value == new_val.data_value, "Data value incorrect"
assert value_wrapper.data_type == new_val.data_type, "Data type incorrect"
assert value_wrapper.data_name == new_val.data_name, "Data name incorrect"
def test_import_export_existing(self, user_factory, project_factory):
"""
Test the import/export mechanism for a project structure.
The project contains the following data types: Connectivity, Surface, MappedArray and ValueWrapper.
"""
test_user = user_factory()
test_project = project_factory(test_user, "TestImportExport2")
zip_path = os.path.join(os.path.dirname(tvb_data.__file__),
'connectivity', 'connectivity_66.zip')
TestFactory.import_zip_connectivity(test_user, test_project, zip_path)
count_operations = dao.get_filtered_operations(test_project.id,
None,
is_count=True)
assert 1 == count_operations, "Invalid ops before export!"
self.zip_path = ExportManager().export_project(test_project)
assert self.zip_path is not None, "Exported file is none"
with pytest.raises(ImportException):
self.import_service.import_project_structure(
self.zip_path, test_user.id)