def import_default_project(admin_user=None):
if not admin_user:
admin_user = TestFactory.create_user()
project_path = os.path.join(os.path.dirname(os.path.dirname(cff_dataset.__file__)), 'Default_Project.zip')
import_service = ImportService()
import_service.import_project_structure(project_path, admin_user.id)
return import_service.created_projects[0]
def import_default_project(admin_user=None):
if not admin_user:
admin_user = TestFactory.create_user()
project_path = os.path.join(os.path.dirname(os.path.dirname(cff_dataset.__file__)), 'Default_Project.zip')
import_service = ImportService()
import_service.import_project_structure(project_path, admin_user.id)
return import_service.created_projects[0]
def update():
"""
Try to import Default_Project, so that new users created with the latest code can share this project.
"""
try:
admins = dao.get_administrators()
service = ImportService()
service.import_project_structure(DATA_FILE, admins[0].id)
except Exception:
LOGGER.exception("Could import DefaultProject!")
def projectupload(self, **data):
"""Upload Project from TVB ZIP."""
self.logger.debug("Uploading ..." + str(data))
try:
upload_param = "uploadedfile"
if upload_param in data and data[upload_param]:
import_service = ImportService()
import_service.import_project_structure(data[upload_param], common.get_logged_user().id)
except ServicesBaseException, excep:
self.logger.warning(excep.message)
common.set_error_message(excep.message)
def update():
"""
Try to import Default_Project, so that new users created with the latest code can share this project.
"""
try:
admins = dao.get_administrators()
service = ImportService()
service.import_project_structure(DATA_FILE, admins[0].id)
except Exception:
LOGGER.exception("Could import DefaultProject!")
def projectupload(self, **data):
"""Upload Project from TVB ZIP."""
self.logger.debug("Uploading ..." + str(data))
try:
upload_param = "uploadedfile"
if upload_param in data and data[upload_param]:
import_service = ImportService()
import_service.import_project_structure(data[upload_param], common.get_logged_user().id)
except ServicesBaseException, excep:
self.logger.warning(excep.message)
common.set_error_message(excep.message)
def run_import(project_path):
## If we would know a UserID to have as admin, next step would not be necessary.
## Make sure at least one user exists in TVB DB:
user_service = UserService()
admins = user_service.get_administrators()
if admins:
admin = admins[0]
else:
## No Admin user was found, we will create one
user_service.create_user("admin", "pass", role=model.ROLE_ADMINISTRATOR,
email="*****@*****.**", validated=True)
admin = user_service.get_administrators()[0]
## Do the actual import of a project from ZIP:
import_service = ImportService()
import_service.import_project_structure(project_path, admin.id)
print "Project imported successfully. Check the Web UI!"
def run_import(project_path):
## If we would know a UserID to have as admin, next step would not be necessary.
## Make sure at least one user exists in TVB DB:
user_service = UserService()
admins = user_service.get_administrators()
if admins:
admin = admins[0]
else:
## No Admin user was found, we will create one
user_service.create_user("admin", "pass", role=model.ROLE_ADMINISTRATOR,
email="*****@*****.**", validated=True, skip_import=True)
admin = user_service.get_administrators()[0]
## Do the actual import of a project from ZIP:
import_service = ImportService()
import_service.import_project_structure(project_path, admin.id)
print("Project imported successfully. Check the Web UI!")
class TestImportService(TransactionalTestCase):
"""
This class contains tests for the tvb.core.services.import_service module.
"""
def transactional_setup_method(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()
TestFactory.import_cff(test_user=self.test_user,
test_project=self.test_project)
self.zip_path = None
def transactional_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()
def test_import_export(self):
"""
Test the import/export mechanism for a project structure.
The project contains the following data types: Connectivity, Surface, MappedArray and ValueWrapper.
"""
result = self.get_all_datatypes()
expected_results = {}
for one_data in result:
expected_results[one_data.gid] = (one_data.module, one_data.type)
#create an array mapped in DB
data = {'param_1': 'some value'}
OperationService().initiate_prelaunch(self.operation,
self.adapter_instance, {},
**data)
inserted = self.flow_service.get_available_datatypes(
self.test_project.id, "tvb.datatypes.arrays.MappedArray")[1]
assert 1 == inserted, "Problems when inserting data"
#create a value wrapper
value_wrapper = self._create_value_wrapper()
count_operations = dao.get_filtered_operations(self.test_project.id,
None,
is_count=True)
assert 2 == count_operations, "Invalid ops number before export!"
# Export project as ZIP
self.zip_path = ExportManager().export_project(self.test_project)
assert self.zip_path is not None, "Exported file is none"
# Remove the original project
self.project_service.remove_project(self.test_project.id)
result, lng_ = self.project_service.retrieve_projects_for_user(
self.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,
self.test_user.id)
result = self.project_service.retrieve_projects_for_user(
self.test_user.id)[0]
assert len(result) == 1, "There should be only one project."
assert result[
0].name == "GeneratedProject", "The project name is not correct."
assert result[
0].description == "test_desc", "The project description is not correct."
self.test_project = result[0]
count_operations = dao.get_filtered_operations(self.test_project.id,
None,
is_count=True)
#1 op. - import cff; 2 op. - save the array wrapper;
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 = self.flow_service.get_available_datatypes(
self.test_project.id,
"tvb.datatypes.mapped_values.ValueWrapper")[0]
assert 1 == len(new_val), "One !=" + str(len(new_val))
new_val = ABCAdapter.load_entity_by_gid(new_val[0][2])
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):
"""
Test the import/export mechanism for a project structure.
The project contains the following data types: Connectivity, Surface, MappedArray and ValueWrapper.
"""
count_operations = dao.get_filtered_operations(self.test_project.id,
None,
is_count=True)
assert 2 == count_operations, "Invalid ops before export!"
self.zip_path = ExportManager().export_project(self.test_project)
assert self.zip_path is not None, "Exported file is none"
with pytest.raises(ProjectImportException):
self.import_service.import_project_structure(
self.zip_path, self.test_user.id)
def _create_timeseries(self):
"""Launch adapter to persist a TimeSeries entity"""
activity_data = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9],
[10, 11, 12]])
time_data = numpy.array([1, 2, 3])
storage_path = FilesHelper().get_project_folder(self.test_project)
time_series = TimeSeries(time_files=None,
activity_files=None,
max_chunk=10,
maxes=None,
mins=None,
data_shape=numpy.shape(activity_data),
storage_path=storage_path,
label_y="Time",
time_data=time_data,
data_name='TestSeries',
activity_data=activity_data,
sample_period=10.0)
self._store_entity(time_series, "TimeSeries",
"tvb.datatypes.time_series")
timeseries_count = self.flow_service.get_available_datatypes(
self.test_project.id, "tvb.datatypes.time_series.TimeSeries")[1]
assert timeseries_count == 1, "Should be only one TimeSeries"
def _create_value_wrapper(self):
"""Persist ValueWrapper"""
value_ = ValueWrapper(data_value=5.0, data_name="my_value")
self._store_entity(value_, "ValueWrapper",
"tvb.datatypes.mapped_values")
valuew = self.flow_service.get_available_datatypes(
self.test_project.id,
"tvb.datatypes.mapped_values.ValueWrapper")[0]
assert len(valuew) == 1, "Should be only one value wrapper"
return ABCAdapter.load_entity_by_gid(valuew[0][2])
def _store_entity(self, entity, type_, module):
"""Launch adapter to store a create a persistent DataType."""
entity.type = type_
entity.module = module
entity.subject = "John Doe"
entity.state = "RAW_STATE"
entity.set_operation_id(self.operation.id)
adapter_instance = StoreAdapter([entity])
OperationService().initiate_prelaunch(self.operation, adapter_instance,
{})
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 ImportServiceTest(TransactionalTestCase):
"""
This class contains tests for the tvb.core.services.import_service module.
"""
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 tearDown(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()
def test_import_export(self):
"""
Test the import/export mechanism for a project structure.
The project contains the following data types: Connectivity, Surface, MappedArray and ValueWrapper.
"""
result = self.get_all_datatypes()
expected_results = {}
for one_data in result:
expected_results[one_data.gid] = (one_data.module, one_data.type)
#create an array mapped in DB
data = {'param_1': 'some value'}
OperationService().initiate_prelaunch(self.operation, self.adapter_instance, {}, **data)
inserted = self.flow_service.get_available_datatypes(self.test_project.id,
"tvb.datatypes.arrays.MappedArray")[1]
self.assertEqual(1, inserted, "Problems when inserting data")
#create a value wrapper
value_wrapper = self._create_value_wrapper()
count_operations = dao.get_filtered_operations(self.test_project.id, None, is_count=True)
self.assertEqual(2, count_operations, "Invalid ops number before export!")
# Export project as ZIP
self.zip_path = ExportManager().export_project(self.test_project)
self.assertTrue(self.zip_path is not None, "Exported file is none")
# Remove the original project
self.project_service.remove_project(self.test_project.id)
result, lng_ = self.project_service.retrieve_projects_for_user(self.test_user.id)
self.assertEqual(0, len(result), "Project Not removed!")
self.assertEqual(0, lng_, "Project Not removed!")
# Now try to import again project
self.import_service.import_project_structure(self.zip_path, self.test_user.id)
result = self.project_service.retrieve_projects_for_user(self.test_user.id)[0]
self.assertEqual(len(result), 1, "There should be only one project.")
self.assertEqual(result[0].name, "GeneratedProject", "The project name is not correct.")
self.assertEqual(result[0].description, "test_desc", "The project description is not correct.")
self.test_project = result[0]
count_operations = dao.get_filtered_operations(self.test_project.id, None, is_count=True)
#1 op. - import cff; 2 op. - save the array wrapper;
self.assertEqual(2, count_operations, "Invalid ops number after export and import !")
for gid in expected_results:
datatype = dao.get_datatype_by_gid(gid)
self.assertEqual(datatype.module, expected_results[gid][0], 'DataTypes not imported correctly')
self.assertEqual(datatype.type, expected_results[gid][1], 'DataTypes not imported correctly')
#check the value wrapper
new_val = self.flow_service.get_available_datatypes(self.test_project.id,
"tvb.datatypes.mapped_values.ValueWrapper")[0]
self.assertEqual(1, len(new_val), "One !=" + str(len(new_val)))
new_val = ABCAdapter.load_entity_by_gid(new_val[0][2])
self.assertEqual(value_wrapper.data_value, new_val.data_value, "Data value incorrect")
self.assertEqual(value_wrapper.data_type, new_val.data_type, "Data type incorrect")
self.assertEqual(value_wrapper.data_name, new_val.data_name, "Data name incorrect")
def test_import_export_existing(self):
"""
Test the import/export mechanism for a project structure.
The project contains the following data types: Connectivity, Surface, MappedArray and ValueWrapper.
"""
count_operations = dao.get_filtered_operations(self.test_project.id, None, is_count=True)
self.assertEqual(2, count_operations, "Invalid ops before export!")
self.zip_path = ExportManager().export_project(self.test_project)
self.assertTrue(self.zip_path is not None, "Exported file is none")
self.assertRaises(ProjectImportException, self.import_service.import_project_structure,
self.zip_path, self.test_user.id)
def _create_timeseries(self):
"""Launch adapter to persist a TimeSeries entity"""
activity_data = numpy.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
time_data = numpy.array([1, 2, 3])
storage_path = FilesHelper().get_project_folder(self.test_project)
time_series = TimeSeries(time_files=None, activity_files=None,
max_chunk=10, maxes=None, mins=None, data_shape=numpy.shape(activity_data),
storage_path=storage_path, label_y="Time", time_data=time_data, data_name='TestSeries',
activity_data=activity_data, sample_period=10.0)
self._store_entity(time_series, "TimeSeries", "tvb.datatypes.time_series")
timeseries_count = self.flow_service.get_available_datatypes(self.test_project.id,
"tvb.datatypes.time_series.TimeSeries")[1]
self.assertEqual(timeseries_count, 1, "Should be only one TimeSeries")
def _create_value_wrapper(self):
"""Persist ValueWrapper"""
value_ = ValueWrapper(data_value=5.0, data_name="my_value")
self._store_entity(value_, "ValueWrapper", "tvb.datatypes.mapped_values")
valuew = self.flow_service.get_available_datatypes(self.test_project.id,
"tvb.datatypes.mapped_values.ValueWrapper")[0]
self.assertEqual(len(valuew), 1, "Should be only one value wrapper")
return ABCAdapter.load_entity_by_gid(valuew[0][2])
def _store_entity(self, entity, type_, module):
"""Launch adapter to store a create a persistent DataType."""
entity.type = type_
entity.module = module
entity.subject = "John Doe"
entity.state = "RAW_STATE"
entity.set_operation_id(self.operation.id)
adapter_instance = StoreAdapter([entity])
OperationService().initiate_prelaunch(self.operation, adapter_instance, {})
def _import(self, export_file, user_id):
""" import a project zip for a user """
# instantiated for every use because it is stateful
import_service = ImportService()
import_service.import_project_structure(export_file, user_id)
return import_service.created_projects[0].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)
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)
def _import(self, export_file, user_id):
""" import a project zip for a user """
# instantiated for every use because it is stateful
import_service = ImportService()
import_service.import_project_structure(export_file, user_id)
return import_service.created_projects[0].id
class ImportExportProjectWithLinksTest(_BaseLinksTest):
def setUpTVB(self):
"""
Adds to the _BaseLinksTest setup the following
2 links from src to dest project
Import/export services
"""
_BaseLinksTest.setUpTVB(self)
dest_id = self.dest_project.id
self.flow_service.create_link([self.red_datatype.id], dest_id)
self.flow_service.create_link([self.blue_datatype.id], dest_id)
self.export_mng = ExportManager()
self.import_service = ImportService()
def test_export(self):
export_file = self.export_mng.export_project(self.dest_project)
with TvbZip(export_file) as z:
self.assertTrue('links-to-external-projects/Operation.xml' in z.namelist())
def _export_and_remove_dest(self):
"""export the destination project and remove it"""
dest_id = self.dest_project.id
export_file = self.export_mng.export_project(self.dest_project)
self.project_service.remove_project(dest_id)
return export_file
def _import_dest(self, export_file):
self.import_service.import_project_structure(export_file, self.user.id)
return self.import_service.created_projects[0].id
def test_links_recreated_on_import(self):
export_file = self._export_and_remove_dest()
imported_proj_id = self._import_dest(export_file)
self.assertEqual(1, self.red_datatypes_in(imported_proj_id))
self.assertEqual(1, self.blue_datatypes_in(imported_proj_id))
links = dao.get_linked_datatypes_for_project(imported_proj_id)
self.assertEqual(2, len(links))
def test_datatypes_recreated_on_import(self):
export_file = self._export_and_remove_dest()
self.project_service.remove_project(self.src_project.id)
# both projects have been deleted
# import should recreate links as datatypes
imported_proj_id = self._import_dest(export_file)
self.assertEqual(1, self.red_datatypes_in(imported_proj_id))
self.assertEqual(1, self.blue_datatypes_in(imported_proj_id))
links = dao.get_linked_datatypes_for_project(imported_proj_id)
self.assertEqual(0, len(links))
def test_datatypes_and_links_recreated_on_import(self):
export_file = self._export_and_remove_dest()
# remove datatype 2 from source project
self.project_service.remove_datatype(self.src_project.id, self.blue_datatype.gid)
imported_proj_id = self._import_dest(export_file)
# both datatypes should be recreated
self.assertEqual(1, self.red_datatypes_in(imported_proj_id))
self.assertEqual(1, self.blue_datatypes_in(imported_proj_id))
# only datatype 1 should be a link
links = dao.get_linked_datatypes_for_project(imported_proj_id)
self.assertEqual(1, len(links))
self.assertEquals(self.red_datatype.gid, links[0].gid)
