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 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)
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)