def test_write_operation_metadata(self):
     """
     Test that a correct XML is created for an operation.
     """
     operation = TestFactory.create_operation(
         test_user=self.test_user, test_project=self.test_project)
     expected_file = self.files_helper.get_operation_meta_file_path(
         self.PROJECT_NAME, operation.id)
     self.assertFalse(os.path.exists(expected_file))
     self.files_helper.write_operation_metadata(operation)
     self.assertTrue(os.path.exists(expected_file))
     operation_meta = XMLReader(expected_file).read_metadata()
     loaded_operation = model.Operation(None, None, None, None)
     loaded_operation.from_dict(operation_meta, dao)
     expected_dict = operation.to_dict()[1]
     found_dict = loaded_operation.to_dict()[1]
     for key, value in expected_dict.iteritems():
         self.assertEqual(str(value), str(found_dict[key]))
     # Now validate that operation metaData can be also updated
     self.assertNotEqual("new_group_name", found_dict['user_group'])
     self.files_helper.update_operation_metadata(self.PROJECT_NAME,
                                                 "new_group_name",
                                                 operation.id)
     found_dict = XMLReader(expected_file).read_metadata()
     self.assertEqual("new_group_name", found_dict['user_group'])
Exemplo n.º 2
0
 def setUp(self):
     """
     Sets up necessary files for the tests.
     """
     self.file_path = os.path.join(os.path.dirname(__file__),
                                   self.TO_BE_READ_FILE)
     self.meta_reader = XMLReader(self.file_path)
Exemplo n.º 3
0
 def test_write_operation_metadata(self):
     """
     Test that a correct XML is created for an operation.
     """
     operation = TestFactory.create_operation(
         test_user=self.test_user, test_project=self.test_project)
     expected_file = self.files_helper.get_operation_meta_file_path(
         self.PROJECT_NAME, operation.id)
     assert not os.path.exists(expected_file)
     self.files_helper.write_operation_metadata(operation)
     assert os.path.exists(expected_file)
     operation_meta = XMLReader(expected_file).read_metadata()
     loaded_operation = model.Operation(None, None, None, None)
     loaded_operation.from_dict(operation_meta,
                                dao,
                                user_id=self.test_user.id)
     expected_dict = operation.to_dict()[1]
     found_dict = loaded_operation.to_dict()[1]
     for key, value in expected_dict.items():
         assert str(value) == str(found_dict[key])
     # Now validate that operation metaData can be also updated
     assert "new_group_name" != found_dict['user_group']
     self.files_helper.update_operation_metadata(self.PROJECT_NAME,
                                                 "new_group_name",
                                                 operation.id)
     found_dict = XMLReader(expected_file).read_metadata()
     assert "new_group_name" == found_dict['user_group']
    def __build_operation_from_file(self, project, operation_file):
        """
        Create Operation entity from metadata file.
        """
        reader = XMLReader(operation_file)
        operation_dict = reader.read_metadata()
        operation_entity = manager_of_class(model.Operation).new_instance()

        return operation_entity.from_dict(operation_dict, dao, self.user_id, project.gid)
Exemplo n.º 5
0
 def test_write_metadata(self):
     """
     Test that an XML file is created and correct data is written in it.
     """
     self.assertFalse(os.path.exists(self.result_path))
     self.meta_writer.write(self.result_path)
     self.assertTrue(os.path.exists(self.result_path))
     reader = XMLReader(self.result_path)
     meta_data = reader.read_metadata()
     for key, value in MetaDataReadXMLTest.EXPECTED_DICTIONARY.iteritems():
         found_value = meta_data[key]
         self.assertEqual(value, found_value)
 def test_write_metadata(self):
     """
     Test that an XML file is created and correct data is written in it.
     """
     self.assertFalse(os.path.exists(self.result_path))
     self.meta_writer.write(self.result_path)
     self.assertTrue(os.path.exists(self.result_path))
     reader = XMLReader(self.result_path)
     meta_data = reader.read_metadata()
     for key, value in MetaDataReadXMLTest.EXPECTED_DICTIONARY.iteritems():
         found_value = meta_data[key]
         self.assertEqual(value, found_value)
Exemplo n.º 7
0
 def test_write_metadata(self):
     """
     Test that an XML file is created and correct data is written in it.
     """
     assert not os.path.exists(self.result_path)
     self.meta_writer.write(self.result_path)
     assert os.path.exists(self.result_path)
     reader = XMLReader(self.result_path)
     meta_data = reader.read_metadata()
     for key, value in TestMetaDataReadXML.EXPECTED_DICTIONARY.items():
         found_value = meta_data[key]
         assert value == found_value
 def test_write_metadata(self):
     """
     Test that an XML file is created and correct data is written in it.
     """
     assert not os.path.exists(self.result_path)
     self.meta_writer.write(self.result_path)
     assert os.path.exists(self.result_path)
     reader = XMLReader(self.result_path)
     meta_data = reader.read_metadata()
     for key, value in TestMetaDataReadXML.EXPECTED_DICTIONARY.iteritems():
         found_value = meta_data[key]
         assert value == found_value
class MetaDataReadXMLTest(unittest.TestCase):
    """
    Tests for tvb.core.entities.file.metadatahandler.XMLReader class.
    """
    TO_BE_READ_FILE = "test_read.xml"
    #Values expected to be read from file
    EXPECTED_DICTIONARY = {
        'status':
        model.STATUS_FINISHED,
        'gid':
        '497b3d59-b3c1-11e1-b2e4-68a86d1bd4fa',
        'method_name':
        'launch',
        'user_group':
        'cff_74',
        'fk_from_algo':
        json.dumps({
            'classname': 'CFF_Importer',
            'identifier': None,
            'module': 'tvb.adapters.uploaders.cff_importer'
        })
    }

    def setUp(self):
        """
        Sets up necessary files for the tests.
        """
        self.file_path = os.path.join(os.path.dirname(__file__),
                                      self.TO_BE_READ_FILE)
        self.meta_reader = XMLReader(self.file_path)

    def test_read_metadata(self):
        """
        Test that content return by read_metadata matches the
        actual content of the XML.
        """
        meta_data = self.meta_reader.read_metadata()
        self.assertTrue(isinstance(meta_data, GenericMetaData))
        for key, value in self.EXPECTED_DICTIONARY.iteritems():
            found_value = meta_data[key]
            self.assertEqual(value, found_value)

    def test_read_gid(self):
        """
        Test that value returned by read_only_element matches the actual value from the XML file.
        """
        read_value = self.meta_reader.read_only_element('gid')
        self.assertTrue(isinstance(read_value, str))
        self.assertEqual(read_value, self.EXPECTED_DICTIONARY['gid'])
Exemplo n.º 10
0
 def __build_operation_from_file(self, project, operation_file):
     """
     Create Operation entity from metadata file.
     """
     operation_dict = XMLReader(operation_file).read_metadata()
     operation_entity = manager_of_class(model.Operation).new_instance()
     return operation_entity.from_dict(operation_dict, dao, self.user_id, project.gid)
Exemplo n.º 11
0
    def _import_image(self, src_folder, metadata_file, project_id,
                      target_images_path):
        """
        Create and store a image entity.
        """
        figure_dict = XMLReader(os.path.join(src_folder,
                                             metadata_file)).read_metadata()
        actual_figure = os.path.join(
            src_folder,
            os.path.split(figure_dict['file_path'])[1])
        if not os.path.exists(actual_figure):
            self.logger.warning("Expected to find image path %s .Skipping" %
                                actual_figure)
            return
        figure_dict['fk_user_id'] = self.user_id
        figure_dict['fk_project_id'] = project_id
        figure_entity = manager_of_class(ResultFigure).new_instance()
        figure_entity = figure_entity.from_dict(figure_dict)
        stored_entity = dao.store_entity(figure_entity)

        # Update image meta-data with the new details after import
        figure = dao.load_figure(stored_entity.id)
        shutil.move(actual_figure, target_images_path)
        self.logger.debug("Store imported figure")
        self.files_helper.write_image_metadata(figure)
Exemplo n.º 12
0
    def update_operation_metadata(self,
                                  project_name,
                                  new_group_name,
                                  operation_id,
                                  is_group=False):
        """
        Update operation meta data.
        :param is_group: when FALSE, use parameter 'new_group_name' for direct assignment on operation.user_group
        when TRUE, update  operation.operation_group.name = parameter 'new_group_name'
        """
        op_path = self.get_operation_meta_file_path(project_name, operation_id)
        if not os.path.exists(op_path):
            self.logger.warning(
                "Trying to update an operation-meta file which does not exist."
                " It could happen in a group where partial entities have errors!"
            )
            return
        op_meta_data = XMLReader(op_path).read_metadata()

        if is_group:
            group_meta_str = op_meta_data[
                DataTypeMetaData.KEY_FK_OPERATION_GROUP]
            group_meta = json.loads(group_meta_str)
            group_meta[
                DataTypeMetaData.KEY_OPERATION_GROUP_NAME] = new_group_name
            op_meta_data[DataTypeMetaData.KEY_FK_OPERATION_GROUP] = json.dumps(
                group_meta)
        else:
            op_meta_data[DataTypeMetaData.KEY_OPERATION_TAG] = new_group_name
        XMLWriter(op_meta_data).write(op_path)
 def setUp(self):
     """
     Sets up necessary files for the tests.
     """
     self.file_path = os.path.join(os.path.dirname(__file__), 
                                   self.TO_BE_READ_FILE)
     self.meta_reader = XMLReader(self.file_path)
    def __populate_project(self, project_path):
        """
        Create and store a Project entity.
        """
        self.logger.debug("Creating project from path: %s" % project_path)
        project_cfg_file = os.path.join(project_path, FilesHelper.TVB_PROJECT_FILE)

        reader = XMLReader(project_cfg_file)
        project_dict = reader.read_metadata()
        project_entity = manager_of_class(model.Project).new_instance()
        project_entity = project_entity.from_dict(project_dict, self.user_id)

        try:
            self.logger.debug("Storing imported project")
            return dao.store_entity(project_entity)
        except IntegrityError, excep:
            self.logger.exception(excep)
            error_msg = ("Could not import project: %s with gid: %s. There is already a "
                         "project with the same name or gid.") % (project_entity.name, project_entity.gid)
            raise ProjectImportException(error_msg)
class MetaDataReadXMLTest(unittest.TestCase):
    """
    Tests for tvb.core.entities.file.metadatahandler.XMLReader class.
    """   
    TO_BE_READ_FILE = "test_read.xml"
    #Values expected to be read from file
    EXPECTED_DICTIONARY = {'status': model.STATUS_FINISHED,
                           'gid': '497b3d59-b3c1-11e1-b2e4-68a86d1bd4fa',
                           'method_name': 'launch',
                           'user_group': 'cff_74',
                           'fk_from_algo': json.dumps({'classname': 'CFF_Importer', 'identifier': None,
                                                       'module': 'tvb.adapters.uploaders.cff_importer'})
                           }
        
    def setUp(self):
        """
        Sets up necessary files for the tests.
        """
        self.file_path = os.path.join(os.path.dirname(__file__), 
                                      self.TO_BE_READ_FILE)
        self.meta_reader = XMLReader(self.file_path)
    
    def test_read_metadata(self):
        """
        Test that content return by read_metadata matches the
        actual content of the XML.
        """
        meta_data = self.meta_reader.read_metadata()
        self.assertTrue(isinstance(meta_data, GenericMetaData))
        for key, value in self.EXPECTED_DICTIONARY.iteritems():
            found_value = meta_data[key]
            self.assertEqual(value, found_value)
        
    def test_read_gid(self):
        """
        Test that value returned by read_only_element matches the actual value from the XML file.
        """
        read_value = self.meta_reader.read_only_element('gid')
        self.assertTrue(isinstance(read_value, str))
        self.assertEqual(read_value, self.EXPECTED_DICTIONARY['gid'])
Exemplo n.º 16
0
 def test_write_project_metadata(self):
     """  Write XML for test-project. """
     self.files_helper.write_project_metadata(self.test_project)
     expected_file = self.files_helper.get_project_meta_file_path(self.PROJECT_NAME)
     assert os.path.exists(expected_file)
     project_meta = XMLReader(expected_file).read_metadata()
     loaded_project = model_project.Project(None, None)
     loaded_project.from_dict(project_meta, self.test_user.id)
     assert self.test_project.name == loaded_project.name
     assert self.test_project.description == loaded_project.description
     assert self.test_project.gid == loaded_project.gid
     expected_dict = self.test_project.to_dict()[1]
     del expected_dict['last_updated']
     found_dict = loaded_project.to_dict()[1]
     del found_dict['last_updated']
     self._dictContainsSubset(expected_dict, found_dict)
     self._dictContainsSubset(found_dict, expected_dict)
Exemplo n.º 17
0
 def test_update_meta_data_simple(self):
     """
     Test the new update metaData for a simple data that is not part of a group.
     """
     inserted_project, gid, _ = self._create_value_wrapper(self.test_user)
     new_meta_data = {DataTypeOverlayDetails.DATA_SUBJECT: "new subject",
                      DataTypeOverlayDetails.DATA_STATE: "second_state",
                      DataTypeOverlayDetails.CODE_GID: gid,
                      DataTypeOverlayDetails.CODE_OPERATION_TAG: 'new user group'}
     self.project_service.update_metadata(new_meta_data)
     
     new_datatype = dao.get_datatype_by_gid(gid)
     self.__check_meta_data(new_meta_data, new_datatype)
     
     op_path = FilesHelper().get_operation_meta_file_path(inserted_project.name, new_datatype.parent_operation.id)
     op_meta = XMLReader(op_path).read_metadata()
     assert op_meta['user_group'] == 'new user group', 'UserGroup not updated!'
Exemplo n.º 18
0
    def _populate_image(self, file_name, project_id):
        """
        Create and store a image entity.
        """
        figure_dict = XMLReader(file_name).read_metadata()
        new_path = os.path.join(os.path.split(file_name)[0], os.path.split(figure_dict['file_path'])[1])
        if not os.path.exists(new_path):
            self.logger.warn("Expected to find image path %s .Skipping" % new_path)

        op = dao.get_operation_by_gid(figure_dict['fk_from_operation'])
        figure_dict['fk_op_id'] = op.id if op is not None else None
        figure_dict['fk_user_id'] = self.user_id
        figure_dict['fk_project_id'] = project_id
        figure_entity = manager_of_class(model.ResultFigure).new_instance()
        figure_entity = figure_entity.from_dict(figure_dict)
        stored_entity = dao.store_entity(figure_entity)

        # Update image meta-data with the new details after import
        figure = dao.load_figure(stored_entity.id)
        self.logger.debug("Store imported figure")
        self.files_helper.write_image_metadata(figure)
Exemplo n.º 19
0
def _rewrite_img_meta(pth, op_id):
    figure_dict = XMLReader(pth).read_metadata()
    figure_dict['file_path'] = op_id + '-' + figure_dict['file_path']
    XMLWriter(figure_dict).write(pth)
Exemplo n.º 20
0
 def read_project_metadata(self, project_path):
     project_cfg_file = os.path.join(project_path, self.TVB_PROJECT_FILE)
     return XMLReader(project_cfg_file).read_metadata()
Exemplo n.º 21
0
 def parse_xml_content(xml_content):
     """
     Delegate reading of some XML content.
     Will parse the XMl and return a dictionary of elements with max 2 levels.
     """
     return XMLReader(None).parse_xml_content_to_dict(xml_content)