class EEGMonitorTest(TransactionalTestCase): """ Unit-tests for BrainViewer. """ def setUp(self): """ Sets up the environment for running the tests; creates a test user, a test project, a connectivity and a surface; imports a CFF data-set """ self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) def tearDown(self): """ Clean-up tests data """ FilesHelper().remove_project_structure(self.test_project.name) def test_launch(self): """ Check that all required keys are present in output from BrainViewer launch. """ zip_path = os.path.join(os.path.dirname(sensors_dataset.__file__), 'EEG_unit_vectors_BrainProducts_62.txt.bz2') TestFactory.import_sensors(self.test_user, self.test_project, zip_path, 'EEG Sensors') sensors = TestFactory.get_entity(self.test_project, SensorsEEG()) time_series = self.datatypeFactory.create_timeseries( self.connectivity, 'EEG', sensors) viewer = EegMonitor() result = viewer.launch(time_series) expected_keys = [ 'tsStateVars', 'tsModes', 'translationStep', 'total_length', 'title', 'timeSetPaths', 'number_of_visible_points', 'normalizedSteps', 'noOfChannels', 'labelsForCheckBoxes', 'label_x', 'graphLabels', 'entities', 'channelsPage' ] for key in expected_keys: self.assertTrue(key in result)
class ConnectivityViewerTest(TransactionalTestCase): """ Unit-tests for BrainViewer. """ def setUp(self): """ Sets up the environment for running the tests; creates a test user, a test project, a connectivity and a surface; imports a CFF data-set """ self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) def tearDown(self): """ Clean-up tests data """ FilesHelper().remove_project_structure(self.test_project.name) def test_launch(self): """ Check that all required keys are present in output from BrainViewer launch. """ viewer = ConnectivityViewer() result = viewer.launch(self.connectivity) expected_keys = [ 'weightsMin', 'weightsMax', 'weights', 'urlWeights', 'urlVertices', 'urlTriangles', 'urlTracts', 'urlPositions', 'urlNormals', 'rightHemisphereJson', 'raysArray', 'rayMin', 'rayMax', 'positions', 'leftHemisphereJson', 'connectivity_entity', 'bothHemisphereJson' ] for key in expected_keys: self.assertTrue(key in result)
class CovarianceViewerTest(TransactionalTestCase): """ Unit-tests for BrainViewer. """ def setUp(self): """ Sets up the environment for running the tests; creates a test user, a test project, a connectivity and a surface; imports a CFF data-set """ self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) def tearDown(self): """ Clean-up tests data """ FilesHelper().remove_project_structure(self.test_project.name) def test_launch(self): """ Check that all required keys are present in output from BrainViewer launch. """ time_series = self.datatypeFactory.create_timeseries(self.connectivity) covariance = self.datatypeFactory.create_covariance(time_series) viewer = CovarianceVisualizer() result = viewer.launch(covariance) expected_keys = [ 'matrix_strides', 'matrix_shape', 'matrix_data', 'mainContent', 'isAdapter' ] for key in expected_keys: self.assertTrue(key in result)
class CrossCoherenceViewerTest(TransactionalTestCase): """ Unit-tests for BrainViewer. """ def setUp(self): self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) def tearDown(self): """ Clean-up tests data """ FilesHelper().remove_project_structure(self.test_project.name) def test_launch(self): """ Check that all required keys are present in output from BrainViewer launch. """ time_series = self.datatypeFactory.create_timeseries(self.connectivity) ccoherence = self.datatypeFactory.create_crosscoherence(time_series) viewer = CrossCoherenceVisualizer() result = viewer.launch(ccoherence) expected_keys = [ 'strides', 'shape', 'mainContent', 'isAdapter', 'frequency', 'coherence' ] for key in expected_keys: self.assertTrue(key in result)
class PSETest(TransactionalTestCase): """ Unit-tests for BrainViewer. """ def setUp(self): self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) def tearDown(self): """ Clean-up tests data """ FilesHelper().remove_project_structure(self.test_project.name) def test_launch(self): """ Check that all required keys are present in output from BrainViewer launch. """ timeseries = self.datatypeFactory.create_timeseries(self.connectivity) viewer = TimeSeries() result = viewer.launch(timeseries) expected_keys = [ 't0', 'shape', 'preview', 'labelsStateVar', 'labelsModes', 'mainContent', 'labels', 'labels_json', 'figsize', 'dt' ] for key in expected_keys: self.assertTrue(key in result)
class RegionMappingImporterTest(TransactionalTestCase): """ Unit-tests for RegionMapping importer. """ TXT_FILE = os.path.join(os.path.dirname(demo_data.__file__), 'original_region_mapping.txt') ZIP_FILE = os.path.join(os.path.dirname(demo_data.__file__), 'original_region_mapping.zip') BZ2_FILE = os.path.join(os.path.dirname(demo_data.__file__), 'original_region_mapping.bz2') # Wrong data WRONG_FILE_1 = os.path.join(os.path.dirname(test_data.__file__), 'region_mapping_wrong_1.txt') WRONG_FILE_2 = os.path.join(os.path.dirname(test_data.__file__), 'region_mapping_wrong_2.txt') WRONG_FILE_3 = os.path.join(os.path.dirname(test_data.__file__), 'region_mapping_wrong_3.txt') def setUp(self): self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) self.connectivity = self._get_entity(Connectivity()) self.surface = self._get_entity(CorticalSurface()) def tearDown(self): """ Clean-up tests data """ FilesHelper().remove_project_structure(self.test_project.name) def _get_entity(self, expected_data, filters=None): data_types = FlowService().get_available_datatypes( self.test_project.id, expected_data.module + "." + expected_data.type, filters) self.assertEqual( 1, len(data_types), "Project should contain only one data type:" + str(expected_data.type)) entity = ABCAdapter.load_entity_by_gid(data_types[0][2]) self.assertTrue(entity is not None, "Instance should not be none") return entity def _import(self, import_file_path, surface_gid, connectivity_gid): """ This method is used for importing region mappings :param import_file_path: absolute path of the file to be imported """ ### Retrieve Adapter instance group = dao.find_group( 'tvb.adapters.uploaders.region_mapping_importer', 'RegionMapping_Importer') importer = ABCAdapter.build_adapter(group) importer.meta_data = { DataTypeMetaData.KEY_SUBJECT: "test", DataTypeMetaData.KEY_STATE: "RAW" } args = { 'mapping_file': import_file_path, 'surface': surface_gid, 'connectivity': connectivity_gid } now = datetime.datetime.now() ### Launch import Operation FlowService().fire_operation(importer, self.test_user, self.test_project.id, **args) # During setup we import a CFF which creates an additional RegionMapping # So, here we have to find our mapping (just imported) data_filter = FilterChain( fields=[FilterChain.datatype + ".create_date"], operations=[">"], values=[now]) region_mapping = self._get_entity(RegionMapping(), data_filter) return region_mapping def test_import_no_surface_or_connectivity(self): """ This method tests import of region mapping without providing a surface or connectivity """ try: self._import(self.TXT_FILE, None, self.connectivity.gid) self.fail("Import should fail in case Surface is missing") except OperationException: # Expected exception pass try: self._import(self.TXT_FILE, self.surface.gid, None) self.fail("Import should fail in case Connectivity is missing") except OperationException: # Expected exception pass def test_import_from_txt(self): """ This method tests import of region mapping from TXT file """ self._import_from_file(self.TXT_FILE) def test_import_from_zip(self): """ This method tests import of region mapping from TXT file """ self._import_from_file(self.ZIP_FILE) def test_import_from_bz2(self): """ This method tests import of region mapping from TXT file """ self._import_from_file(self.BZ2_FILE) def _import_from_file(self, import_file): """ This method tests import of region mapping from TXT file """ region_mapping = self._import(import_file, self.surface.gid, self.connectivity.gid) self.assertTrue(region_mapping.surface is not None) self.assertTrue(region_mapping.connectivity is not None) array_data = region_mapping.array_data self.assertTrue(array_data is not None) self.assertEqual(16384, len(array_data)) def test_import_wrong_file_content(self): """ This method tests import of region mapping with: - a wrong region number - wrong number of regions - negative region number """ try: self._import(self.WRONG_FILE_1, self.surface.gid, self.connectivity.gid) self.fail("Import should fail in case of invalid region number") except OperationException: # Expected exception pass try: self._import(self.WRONG_FILE_2, self.surface.gid, self.connectivity.gid) self.fail("Import should fail in case of invalid regions number") except OperationException: # Expected exception pass try: self._import(self.WRONG_FILE_3, self.surface.gid, self.connectivity.gid) self.fail( "Import should fail in case of invalid region number (negative number)" ) except OperationException: # Expected exception pass
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 BrainViewerTest(TransactionalTestCase): """ Unit-tests for BrainViewer. """ def setUp(self): self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() TestFactory.import_cff(test_user=self.test_user, test_project=self.test_project) zip_path = os.path.join(os.path.dirname(surface_dataset.__file__), 'face-surface.zip') TestFactory.import_surface_zip(self.test_user, self.test_project, zip_path, 'Face', 1) zip_path = os.path.join(os.path.dirname(surface_dataset.__file__), 'eeg_skin_surface.zip') TestFactory.import_surface_zip(self.test_user, self.test_project, zip_path, 'EEG Cap', 1) self.connectivity = TestFactory.get_entity(self.test_project, Connectivity()) self.assertTrue(self.connectivity is not None) self.surface = TestFactory.get_entity(self.test_project, CorticalSurface()) self.assertTrue(self.surface is not None) self.face_surface = TestFactory.get_entity(self.test_project, FaceSurface()) self.assertTrue(self.face_surface is not None) self.assertTrue( TestFactory.get_entity(self.test_project, EEGCap()) is not None) def tearDown(self): """ Clean-up tests data """ FilesHelper().remove_project_structure(self.test_project.name) def test_launch(self): """ Check that all required keys are present in output from BrainViewer launch. """ time_series = self.datatypeFactory.create_timeseries(self.connectivity) viewer = BrainViewer() result = viewer.launch(time_series=time_series) expected_keys = [ 'urlVertices', 'urlNormals', 'urlTriangles', 'urlMeasurePointsLabels', 'title', 'time_series', 'shelfObject', 'pageSize', 'labelsStateVar', 'nrOfPages', 'labelsModes', 'minActivityLabels', 'minActivity', 'measure_points', 'maxActivity', 'isOneToOneMapping', 'isAdapter', 'extended_view', 'base_activity_url', 'alphas_indices' ] for key in expected_keys: self.assertTrue(key in result and result[key] is not None) self.assertFalse(result['extended_view']) def test_get_required_memory(self): """ Brainviewer should know required memory so expect positive number and not -1. """ time_series = self.datatypeFactory.create_timeseries(self.connectivity) self.assertTrue( BrainViewer().get_required_memory_size(time_series) > 0) def test_generate_preview(self): """ Check that all required keys are present in preview generate by BrainViewer. """ time_series = self.datatypeFactory.create_timeseries(self.connectivity) viewer = BrainViewer() result = viewer.generate_preview(time_series, (500, 200)) expected_keys = [ 'urlVertices', 'urlNormals', 'urlTriangles', 'pageSize', 'nrOfPages', 'minActivityLabels', 'minActivity', 'maxActivity', 'isOneToOneMapping', 'isAdapter', 'base_activity_url', 'alphas_indices' ] for key in expected_keys: self.assertTrue(key in result and result[key] is not None) def test_launch_eeg(self): zip_path = os.path.join(os.path.dirname(sensors_dataset.__file__), 'EEG_unit_vectors_BrainProducts_62.txt.bz2') TestFactory.import_sensors(self.test_user, self.test_project, zip_path, 'EEG Sensors') sensors = TestFactory.get_entity(self.test_project, SensorsEEG()) time_series = self.datatypeFactory.create_timeseries( self.connectivity, 'EEG', sensors) time_series.configure() viewer = BrainEEG() result = viewer.launch(time_series) expected_keys = [ 'urlVertices', 'urlNormals', 'urlTriangles', 'urlMeasurePointsLabels', 'title', 'time_series', 'shelfObject', 'pageSize', 'labelsStateVar', 'nrOfPages', 'labelsModes', 'minActivityLabels', 'minActivity', 'measure_points', 'maxActivity', 'isOneToOneMapping', 'isAdapter', 'extended_view', 'base_activity_url', 'alphas_indices' ] for key in expected_keys: self.assertTrue(key in result and result[key] is not None) self.assertTrue(result['extended_view'])
class NIFTIImporterTest(TransactionalTestCase): """ Unit-tests for NIFTI importer. """ NII_FILE = os.path.join(os.path.dirname(demo_data.__file__), 'minimal.nii') GZ_NII_FILE = os.path.join(os.path.dirname(demo_data.__file__), 'minimal.nii.gz') TVB_NII_FILE = os.path.join(os.path.dirname(demo_data.__file__), 'tvb_nifti_demo_data.nii.gz') WRONG_NII_FILE = os.path.abspath(__file__) DEFAULT_ORIGIN = [[0.0, 0.0, 0.0]] UNKNOWN_STR = "unknown" def setUp(self): self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() def tearDown(self): """ Clean-up tests data """ FilesHelper().remove_project_structure(self.test_project.name) def _import(self, import_file_path=None): """ This method is used for importing data in NIFIT format :param import_file_path: absolute path of the file to be imported """ ### Retrieve Adapter instance group = dao.find_group('tvb.adapters.uploaders.nifti_importer', 'NIFTIImporter') 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) time_series = TimeSeries() data_types = FlowService().get_available_datatypes( self.test_project.id, time_series.module + "." + time_series.type) self.assertEqual(1, len(data_types), "Project should contain only one data type.") time_series = ABCAdapter.load_entity_by_gid(data_types[0][2]) self.assertTrue(time_series is not None, "TimeSeries should not be none") return time_series def test_import_demo_nii_data(self): """ This method tests import of a NIFTI file. """ time_series = self._import(self.TVB_NII_FILE) # Since self.assertAlmostEquals is not available on all machine # We compare floats as following self.assertTrue(abs(2.0 - time_series.sample_period) <= 0.001) self.assertEqual("sec", str(time_series.sample_period_unit)) self.assertEqual(0.0, time_series.start_time) self.assertTrue(time_series.title is not None) data_shape = time_series.read_data_shape() self.assertEquals(4, len(data_shape)) # We have only one entry for time dimension self.assertEqual(150, data_shape[0]) dimension_labels = time_series.labels_ordering self.assertTrue(dimension_labels is not None) self.assertEquals(4, len(dimension_labels)) volume = time_series.volume self.assertTrue(volume is not None) self.assertTrue(numpy.equal(self.DEFAULT_ORIGIN, volume.origin).all()) self.assertEquals("mm", volume.voxel_unit) def test_import_nii_without_time_dimension(self): """ This method tests import of a NIFTI file. """ time_series = self._import(self.NII_FILE) self.assertEqual(1.0, time_series.sample_period) self.assertEqual(self.UNKNOWN_STR, str(time_series.sample_period_unit)) self.assertEqual(0.0, time_series.start_time) self.assertTrue(time_series.title is not None) data_shape = time_series.read_data_shape() self.assertEquals(4, len(data_shape)) # We have only one entry for time dimension self.assertEqual(1, data_shape[0]) dimension_labels = time_series.labels_ordering self.assertTrue(dimension_labels is not None) self.assertEquals(4, len(dimension_labels)) volume = time_series.volume self.assertTrue(volume is not None) self.assertTrue(numpy.equal(self.DEFAULT_ORIGIN, volume.origin).all()) self.assertTrue(numpy.equal([3.0, 3.0, 3.0], volume.voxel_size).all()) self.assertEquals(self.UNKNOWN_STR, volume.voxel_unit) def test_import_nifti_compressed(self): """ This method tests import of a NIFTI file compressed in GZ format. """ time_series = self._import(self.GZ_NII_FILE) self.assertEqual(1.0, time_series.sample_period) self.assertEqual(self.UNKNOWN_STR, str(time_series.sample_period_unit)) self.assertEqual(0.0, time_series.start_time) self.assertTrue(time_series.title is not None) data_shape = time_series.read_data_shape() self.assertEquals(4, len(data_shape)) # We have only one entry for time dimension self.assertEqual(1, data_shape[0]) dimension_labels = time_series.labels_ordering self.assertTrue(dimension_labels is not None) self.assertEquals(4, len(dimension_labels)) volume = time_series.volume self.assertTrue(volume is not None) self.assertTrue(numpy.equal(self.DEFAULT_ORIGIN, volume.origin).all()) self.assertTrue(numpy.equal([3.0, 3.0, 3.0], volume.voxel_size).all()) self.assertEquals(self.UNKNOWN_STR, volume.voxel_unit) def test_import_wrong_nii_file(self): """ This method tests import of a file in a wrong format """ try: self._import(self.WRONG_NII_FILE) self.fail("Import should fail in case of a wrong NIFTI format.") except OperationException: # Expected exception pass
class GIFTISurfaceImporterTest(TransactionalTestCase): """ Unit-tests for GIFTI Surface importer. """ GIFTI_SURFACE_FILE = os.path.join(os.path.dirname(demo_data.__file__), 'sample.cortex.surf.gii') GIFTI_TIME_SERIES_FILE = os.path.join(os.path.dirname(demo_data.__file__), 'gifti.case1.time_series.L.time.gii') WRONG_GII_FILE = os.path.abspath(__file__) def setUp(self): self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() def tearDown(self): """ Clean-up tests data """ FilesHelper().remove_project_structure(self.test_project.name) def _importSurface(self, import_file_path=None): """ This method is used for importing data in GIFIT format :param import_file_path: absolute path of the file to be imported """ ### Retrieve Adapter instance group = dao.find_group('tvb.adapters.uploaders.gifti_surface_importer', 'GIFTISurfaceImporter') 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) surface = CorticalSurface() data_types = FlowService().get_available_datatypes(self.test_project.id, surface.module + "." + surface.type) self.assertEqual(1, len(data_types), "Project should contain only one data type.") surface = ABCAdapter.load_entity_by_gid(data_types[0][2]) self.assertTrue(surface is not None, "TimeSeries should not be none") return surface def test_import_surface_gifti_data(self): """ This method tests import of a surface from GIFTI file. !!! Important: We changed this test to execute only GIFTI parse because storing surface it takes too long (~ 9min) since normals needs to be calculated. """ operation_id = self.datatypeFactory.get_operation().id storage_path = FilesHelper().get_operation_folder(self.test_project.name, operation_id) parser = GIFTIParser(storage_path, operation_id) surface = parser.parse(self.GIFTI_SURFACE_FILE) self.assertEqual(131342, len(surface.vertices)) self.assertEqual(262680, len(surface.triangles)) def test_import_timeseries_gifti_data(self): """ This method tests import of a time series from GIFTI file. !!! Important: We changed this test to execute only GIFTI parse because storing surface it takes too long (~ 9min) since normals needs to be calculated. """ operation_id = self.datatypeFactory.get_operation().id storage_path = FilesHelper().get_operation_folder(self.test_project.name, operation_id) parser = GIFTIParser(storage_path, operation_id) time_series = parser.parse(self.GIFTI_TIME_SERIES_FILE) data_shape = time_series.read_data_shape() self.assertEqual(135, data_shape[0]) self.assertEqual(143479, data_shape[1]) def test_import_wrong_gii_file(self): """ This method tests import of a file in a wrong format """ try: self._importSurface(self.WRONG_GII_FILE) self.fail("Import should fail in case of a wrong GIFTI format.") except OperationException: # Expected exception pass
class SensorsImporterTest(TransactionalTestCase): """ Unit-tests for Sensors importer. """ EEG_FILE = os.path.join(os.path.dirname(demo_data.__file__), 'EEG_unit_vectors_BrainProducts_62.txt.bz2') MEG_FILE = os.path.join(os.path.dirname(demo_data.__file__), 'meg_channels_reg13.txt.bz2') def setUp(self): self.datatypeFactory = DatatypesFactory() self.test_project = self.datatypeFactory.get_project() self.test_user = self.datatypeFactory.get_user() self.importer = Sensors_Importer() def tearDown(self): """ Clean-up tests data """ FilesHelper().remove_project_structure(self.test_project.name) def _import(self, import_file_path, sensors_type, expected_data): """ This method is used for importing sensors :param import_file_path: absolute path of the file to be imported """ ### Retrieve Adapter instance group = dao.find_group('tvb.adapters.uploaders.sensors_importer', 'Sensors_Importer') importer = ABCAdapter.build_adapter(group) importer.meta_data = {DataTypeMetaData.KEY_SUBJECT: "", DataTypeMetaData.KEY_STATE: "RAW"} args = {'sensors_file': import_file_path, 'sensors_type': sensors_type} ### Launch import Operation FlowService().fire_operation(importer, self.test_user, self.test_project.id, **args) data_types = FlowService().get_available_datatypes(self.test_project.id, expected_data.module + "." + expected_data.type) self.assertEqual(1, len(data_types), "Project should contain only one data type = Sensors.") time_series = ABCAdapter.load_entity_by_gid(data_types[0][2]) self.assertTrue(time_series is not None, "Sensors instance should not be none") return time_series def test_import_eeg_sensors(self): """ This method tests import of a file containing EEG sensors. """ eeg_sensors = self._import(self.EEG_FILE, self.importer.EEG_SENSORS, SensorsEEG()) expected_size = 62 self.assertTrue(eeg_sensors.labels is not None) self.assertEqual(expected_size, len(eeg_sensors.labels)) self.assertEqual(expected_size, len(eeg_sensors.locations)) self.assertEqual((expected_size, 3), eeg_sensors.locations.shape) self.assertEqual(expected_size, eeg_sensors.number_of_sensors) def test_import_meg_sensors(self): """ This method tests import of a file containing MEG sensors. """ meg_sensors = self._import(self.MEG_FILE, self.importer.MEG_SENSORS, SensorsMEG()) expected_size = 151 self.assertTrue(meg_sensors.labels is not None) self.assertEqual(expected_size, len(meg_sensors.labels)) self.assertEqual(expected_size, len(meg_sensors.locations)) self.assertEqual((expected_size, 3), meg_sensors.locations.shape) self.assertEqual(expected_size, meg_sensors.number_of_sensors) self.assertTrue(meg_sensors.has_orientation) self.assertEqual(expected_size, len(meg_sensors.orientations)) self.assertEqual((expected_size, 3), meg_sensors.orientations.shape) def test_import_meg_without_orientation(self): """ This method tests import of a file without orientation. """ try: self._import(self.EEG_FILE, self.importer.MEG_SENSORS, SensorsMEG()) self.fail("Import should fail in case of a MEG import without orientation.") except OperationException: # Expected exception pass def test_import_internal_sensors(self): """ This method tests import of a file containing internal sensors. """ internal_sensors = self._import(self.EEG_FILE, self.importer.INTERNAL_SENSORS, SensorsInternal()) expected_size = 62 self.assertTrue(internal_sensors.labels is not None) self.assertEqual(expected_size, len(internal_sensors.labels)) self.assertEqual(expected_size, len(internal_sensors.locations)) self.assertEqual((expected_size, 3), internal_sensors.locations.shape) self.assertEqual(expected_size, internal_sensors.number_of_sensors)