class PSETest(TransactionalTestCase): """ Unit-tests for BrainViewer. """ def setUp(self): """ Sets up the environment for running the tests; creates a datatype group """ self.datatypeFactory = DatatypesFactory() self.group = self.datatypeFactory.create_datatype_group() def test_launch_discrete(self): """ Check that all required keys are present in output from PSE Discrete Adapter launch. """ viewer = DiscretePSEAdapter() result = viewer.launch(self.group) expected_keys = ['status', 'size_metric', 'series_array', 'min_shape_size_weight', 'min_color', 'max_shape_size_weight', 'max_color', 'mainContent', 'labels_y', 'labels_x', 'isAdapter', 'has_started_ops', 'datatype_group_gid', 'datatypes_dict', 'data', 'color_metric'] for key in expected_keys: self.assertTrue(key in result) self.assertEqual(self.group.gid, result["datatype_group_gid"]) self.assertEqual(False, result["has_started_ops"]) def test_launch_isocline(self): """ Check that all required keys are present in output from PSE Discrete Adapter launch. """ viewer = IsoclinePSEAdapter() result = viewer.launch(self.group) self.assertEqual(viewer._ui_name, result["title"]) self.assertEqual(config.SERVER_IP, result["serverIp"]) self.assertEqual(config.MPLH5_SERVER_PORT, result["serverPort"]) self.assertEqual(0, len(result["figureNumbers"])) self.assertEqual(0, len(result["metrics"]))
class TVBImporterTest(TransactionalTestCase): """ Unit-tests for TVB importer. """ TVB_EXPORTER = "TVBExporter" def setUp(self): export_manager = ExportManager() self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() # Generate simple data type and export it to H5 file self.datatype = self.datatypeFactory.create_datatype_with_storage() _, exported_h5_file, _ = export_manager.export_data(self.datatype, self.TVB_EXPORTER, self.test_project) # Copy H5 file to another location since the original one / exported # will be deleted with the project _, h5_file_name = os.path.split(exported_h5_file) shutil.copy(exported_h5_file, cfg.TVB_TEMP_FOLDER) self.h5_file_path = os.path.join(cfg.TVB_TEMP_FOLDER, h5_file_name) self.assertTrue(os.path.exists(self.h5_file_path), "Simple data type was not exported correct") # Generate data type group and export it to ZIP file self.datatype_group = self.datatypeFactory.create_datatype_group() _, self.zip_file_path, _ = export_manager.export_data(self.datatype_group, self.TVB_EXPORTER, self.test_project) self.assertTrue(os.path.exists(self.zip_file_path), "Data type group was not exported correct") FilesHelper().remove_project_structure(self.test_project.name) self.clean_database(delete_folders=False) # Recreate project, but a clean one where to import data self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() def _import(self, import_file_path=None): """ This method is used for importing data in TVB format :param import_file_path: absolute path of the file to be imported """ ### Retrieve Adapter instance group = dao.find_group('tvb.adapters.uploaders.tvb_importer', 'TVBImporter') importer = ABCAdapter.build_adapter(group) importer.meta_data = {DataTypeMetaData.KEY_SUBJECT: "", DataTypeMetaData.KEY_STATE: "RAW"} args = {'data_file': import_file_path} ### Launch import Operation FlowService().fire_operation(importer, self.test_user, self.test_project.id, **args) def test_zip_import(self): """ This method tests import of TVB data in zip format (which imply multiple data types in the same zip file - exported from a group) """ self._import(self.zip_file_path) data_types = FlowService().get_available_datatypes(self.test_project.id, self.datatype.module + "." + self.datatype.type) self.assertEqual(3, len(data_types), "3 datatypes should have been imported from group.") def test_h5_import(self): """ This method tests import of TVB data in h5 format. Single data type / import """ self._import(self.h5_file_path) data_types = FlowService().get_available_datatypes(self.test_project.id, self.datatype.module + "." + self.datatype.type) self.assertEqual(1, len(data_types), "Project should contain only one data type.") data_type_entity = ABCAdapter.load_entity_by_gid(data_types[0][2]) self.assertTrue(data_type_entity is not None, "Datatype should not be none") self.assertEqual(self.datatype.gid, data_type_entity.gid, "Imported datatype should have the same gid") def test_import_invalid_file(self): """ This method tests import of a file which does not exists or does not have a supported format. """ try: self._import("invalid_path") self.fail("System should throw an exception if trying to import an invalid file") except OperationException: # Expected pass # Now try to generate a file on disk with wrong format and import that file_path = os.path.join(cfg.TVB_TEMP_FOLDER, "dummy_file.txt") with open(file_path, "w") as f: f.write("dummy text") try: self._import(file_path) self.fail("System should throw an exception if trying to import a file with wrong format") except OperationException: # Expected pass
class ExportersTest(TransactionalTestCase): """ Test export functionality. """ TVB_EXPORTER = "TVBExporter" CIFTI_EXPORTER = "CIFTIExporter" def setUp(self): self.export_manager = ExportManager() self.datatypeFactory = DatatypesFactory() self.project = self.datatypeFactory.get_project() def tearDown(self): """ Clean-up tests data """ project = self.datatypeFactory.get_project() FilesHelper().remove_project_structure(project.name) # Remove EXPORT folder export_folder = os.path.join(cfg.TVB_STORAGE, ExportManager.EXPORT_FOLDER_NAME) if os.path.exists(export_folder): shutil.rmtree(export_folder) def test_get_exporters_for_data(self): """ Test retrieval of exporters that can be used for a given data. """ datatype = self.datatypeFactory.create_simple_datatype() exporters = self.export_manager.get_exporters_for_data(datatype) # Only TVB export can export any type of data type self.assertEqual(1, len(exporters), "Incorrect number of exporters.") def test_get_exporters_for_data_with_no_data(self): """ Test retrieval of exporters when data == None. """ self.assertRaises(InvalidExportDataException, self.export_manager.get_exporters_for_data, None) def test_tvb_export_of_simple_datatype(self): """ Test export of a data type which has no data stored on file system """ datatype = self.datatypeFactory.create_simple_datatype() file_name, file_path, _ = self.export_manager.export_data( datatype, self.TVB_EXPORTER, self.project) self.assertTrue(file_name is not None, "Export process should return a file name") self.assertTrue(file_path is not None, "Export process should return path to export file") self.assertTrue(os.path.exists(file_path), "Could not find export file: %s on disk." % file_path) def test_tvb_export_of_datatype_with_storage(self): """ Test export of a data type which has no data stored on file system """ datatype = self.datatypeFactory.create_datatype_with_storage() file_name, file_path, _ = self.export_manager.export_data( datatype, self.TVB_EXPORTER, self.project) self.assertTrue(file_name is not None, "Export process should return a file name") self.assertTrue(file_path is not None, "Export process should return path to export file") self.assertTrue(os.path.exists(file_path), "Could not find export file: %s on disk." % file_path) def test_tvb_export_for_datatype_group(self): """ This method checks export of a data type group """ datatype_group = self.datatypeFactory.create_datatype_group() file_name, file_path, _ = self.export_manager.export_data( datatype_group, self.TVB_EXPORTER, self.project) self.assertTrue(file_name is not None, "Export process should return a file name") self.assertTrue(file_path is not None, "Export process should return path to export file") self.assertTrue(os.path.exists(file_path), "Could not find export file: %s on disk." % file_path) # Now check if the generated file is a correct ZIP file self.assertTrue(zipfile.is_zipfile(file_path), "Generated file is not a valid ZIP file") with closing(zipfile.ZipFile(file_path)) as zip_file: list_of_files = zip_file.namelist() count_datatypes = dao.count_datatypes_in_group(datatype_group.id) # Check if ZIP files contains files for data types + operation self.assertEqual( count_datatypes * 2, len(list_of_files), "Should have 2 x nr datatypes files, one for operations one for datatypes" ) def test_export_with_invalid_data(self): """ Test scenarios when data provided to export method is invalid """ # Test with no datatype self.assertRaises(InvalidExportDataException, self.export_manager.export_data, None, self.TVB_EXPORTER, self.project) # Test with no exporter datatype = self.datatypeFactory.create_datatype_with_storage() self.assertRaises(ExportException, self.export_manager.export_data, datatype, None, self.project) # test with wrong exporter self.assertRaises(ExportException, self.export_manager.export_data, datatype, "wrong_exporter", self.project) # test with no project folder self.assertRaises(ExportException, self.export_manager.export_data, datatype, self.TVB_EXPORTER, None) def test_export_project_failure(self): """ This method tests export of project with None data """ self.assertRaises(ExportException, self.export_manager.export_project, None) def tet_export_project(self): """ Test export of a project """ project = self.datatypeFactory.get_project() export_file = self.export_manager.export_project(project) self.assertTrue(export_file is not None, "Export process should return path to export file") self.assertTrue( os.path.exists(export_file), "Could not find export file: %s on disk." % export_file) # Now check if the generated file is a correct ZIP file self.assertTrue(zipfile.is_zipfile(export_file), "Generated file is not a valid ZIP file")