def test_copy(self): # create 1 SupportedResTypes obj with required params resource.create_metadata_element( self.resWebApp.short_id, 'SupportedResTypes', supported_res_types=['NetcdfResource']) self.assertEqual(SupportedResTypes.objects.all().count(), 1) # set url launching pattern for aggregations metadata = [{ 'requesturlbaseaggregation': { 'value': 'https://www.google.com?agg_path=${HS_AGG_PATH}' } }] self.resWebApp.metadata.update(metadata, self.user) resource.create_metadata_element( self.resWebApp.short_id, 'SupportedAggTypes', supported_agg_types=['GeoRasterLogicalFile']) self.assertEqual(1, SupportedAggTypes.objects.all().count()) # make a new copy of web app new_web_app = create_empty_resource(self.resWebApp.short_id, self.user, action='copy') new_web_app = copy_resource(self.resWebApp, new_web_app) # test the new copy is a web app self.assertTrue(isinstance(new_web_app, ToolResource)) # test that added types are copied self.assertEqual(2, SupportedResTypes.objects.all().count()) self.assertEqual(2, SupportedAggTypes.objects.all().count())
def test_update_variable_orig(self): self.assertEqual(len(self.refts_res.metadata.variables.all()), 0) resource.create_metadata_element( self.refts_res.short_id, 'Variable', name='test variable name', code='test code', data_type='test data type', sample_medium='test sample medium') self.assertEqual(len(self.refts_res.metadata.variables.all()), 1) self.assertEqual(self.refts_res.metadata.variables.all()[0].name, 'test variable name') self.assertEqual(self.refts_res.metadata.variables.all()[0].code, 'test code') self.assertEqual(self.refts_res.metadata.variables.all()[0].data_type, 'test data type') self.assertEqual(self.refts_res.metadata.variables.all()[0].sample_medium, 'test sample medium') v = self.refts_res.metadata.variables.filter(name='test variable name')[0] resource.update_metadata_element( self.refts_res.short_id, 'Variable', v.id, name='test variable name2', code='test code2', data_type='test data type2', sample_medium='test sample medium2') self.assertEqual(self.refts_res.metadata.variables.all()[0].name, 'test variable name2') self.assertEqual(self.refts_res.metadata.variables.all()[0].code, 'test code2') self.assertEqual(self.refts_res.metadata.variables.all()[0].data_type, 'test data type2') self.assertEqual(self.refts_res.metadata.variables.all()[0].sample_medium, 'test sample medium2')
def setUp(self): self.group, _ = Group.objects.get_or_create(name='Hydroshare Author') self.user = hydroshare.create_account( '*****@*****.**', username='******', first_name='Creator_FirstName', last_name='Creator_LastName', superuser=False, groups=[self.group] ) self.refts_res = hydroshare.create_resource( resource_type='RefTimeSeries', owner=self.user, title='Test RefTS resource') resource.create_metadata_element(self.refts_res.short_id, 'QualityControlLevel', value='test quality level') resource.create_metadata_element(self.refts_res.short_id, 'ReferenceURL', value='www.example.com', type='REST') resource.create_metadata_element(self.refts_res.short_id, 'Method', value='test method') resource.create_metadata_element( self.refts_res.short_id, 'Variable', name='test variable name', code='test code', data_type='test data type', sample_medium='test sample medium') resource.create_metadata_element( self.refts_res.short_id, 'Site', name='test site name', code='test site code', latitude=150.15, longitude=150.15)
def test_update_site_orig(self): self.assertEqual(len(self.refts_res.metadata.sites.all()), 0) resource.create_metadata_element( self.refts_res.short_id, 'Site', name='test site name', code='test site code', latitude=150.15, longitude=150.15) self.assertEqual(len(self.refts_res.metadata.sites.all()), 1) self.assertEqual(self.refts_res.metadata.sites.all()[0].name, 'test site name') self.assertEqual(self.refts_res.metadata.sites.all()[0].code, 'test site code') self.assertEqual(self.refts_res.metadata.sites.all()[0].latitude, Decimal('150.150000')) self.assertEqual(self.refts_res.metadata.sites.all()[0].longitude, Decimal('150.150000')) s = self.refts_res.metadata.sites.filter(name='test site name')[0] resource.update_metadata_element( self.refts_res.short_id, 'Site', s.id, name='test site name2', code='test site code2', latitude=150.17, longitude=150.17) self.assertEqual(len(self.refts_res.metadata.sites.all()), 1) self.assertEqual(self.refts_res.metadata.sites.all()[0].name, 'test site name2') self.assertEqual(self.refts_res.metadata.sites.all()[0].code, 'test site code2') self.assertEqual(self.refts_res.metadata.sites.all()[0].latitude, Decimal('150.170000')) self.assertEqual(self.refts_res.metadata.sites.all()[0].longitude, Decimal('150.170000'))
def test_copy(self): # create 1 SupportedResTypes obj with required params resource.create_metadata_element(self.resWebApp.short_id, 'SupportedResTypes', supported_res_types=['NetcdfResource']) self.assertEqual(SupportedResTypes.objects.all().count(), 1) # set url launching pattern for aggregations metadata = [{'requesturlbaseaggregation': { 'value': 'https://www.google.com?agg_path=${HS_AGG_PATH}'}}] self.resWebApp.metadata.update(metadata, self.user) resource.create_metadata_element(self.resWebApp.short_id, 'SupportedAggTypes', supported_agg_types=['GeoRasterLogicalFile']) self.assertEqual(1, SupportedAggTypes.objects.all().count()) # make a new copy of web app new_web_app = create_empty_resource(self.resWebApp.short_id, self.user, action='copy') new_web_app = copy_resource(self.resWebApp, new_web_app) # test the new copy is a web app self.assertTrue(isinstance(new_web_app, ToolResource)) # test that added types are copied self.assertEqual(2, SupportedResTypes.objects.all().count()) self.assertEqual(2, SupportedAggTypes.objects.all().count())
def test_agg_types(self): # set url launching pattern for aggregations metadata = [{'requesturlbaseaggregation': { 'value': 'https://www.google.com?agg_path=${HS_AGG_PATH}'}}] self.resWebApp.metadata.update(metadata, self.user) self.assertEqual(RequestUrlBaseAggregation.objects.all().count(), 1) # set web app to launch for geo raster self.resWebApp.metadata.update(metadata, self.user) resource.create_metadata_element(self.resWebApp.short_id, 'SupportedAggTypes', supported_agg_types=['GeoRasterLogicalFile']) self.assertEqual(1, SupportedAggTypes.objects.all().count()) # add a geo raster aggregation to the resource open_file = open(self.test_file_path.format("small_logan.tif"), 'rb') resource_file_add_process(resource=self.resComposite, files=(open_file,), user=self.user) # setup the web app to be launched by the resource url = '/resource/' + self.resComposite.short_id + '/' request = self.factory.get(url) request.user = self.user self.assertEqual(self.resWebApp.extra_metadata, {}) self.resWebApp.extra_metadata = {tool_app_key: 'test-app-value'} self.resWebApp.save() self.assertNotEqual(self.resWebApp.extra_metadata, {}) self.assertEqual(self.resWebApp.extra_metadata[tool_app_key], 'test-app-value') self.assertEqual(self.resComposite.extra_metadata, {}) self.resComposite.extra_metadata = {tool_app_key: 'test-app-value'} self.resComposite.save() self.assertNotEqual(self.resComposite.extra_metadata, {}) self.assertEqual(self.resComposite.extra_metadata[tool_app_key], 'test-app-value') url = '/resource/' + self.resComposite.short_id + '/' request = self.factory.get(url) request.user = self.user # get the web tools and ensure agg_types is there relevant_tools = resource_level_tool_urls(self.resComposite, request) self.assertIsNotNone(relevant_tools, msg='relevant_tools should not be None with appkey ' 'matching') tc = relevant_tools['resource_level_app_counter'] self.assertEqual(0, tc) tl = relevant_tools['tool_list'][0] self.assertEqual(self.resWebApp.short_id, tl['res_id']) self.assertEqual('GeoRasterLogicalFile', tl['agg_types']) self.assertEqual('', tl['file_extensions']) # Remove appkey to turn off openwithlist for this resource self.resWebApp.extra_metadata = {} self.resWebApp.save() relevant_tools = resource_level_tool_urls(self.resComposite, request) self.assertIsNone(relevant_tools, msg='relevant_tools should have no approved resources')
def test_delete_method_orig(self): self.assertEqual(len(self.refts_res.metadata.methods.all()), 0) resource.create_metadata_element(self.refts_res.short_id, 'Method', value='test method') self.assertEqual(len(self.refts_res.metadata.methods.all()), 1) self.assertEqual(self.refts_res.metadata.methods.all()[0].value, 'test method') m = self.refts_res.metadata.methods.filter(value='test method')[0] resource.delete_metadata_element(self.refts_res.short_id, 'Method', m.id) self.assertEqual(len(self.refts_res.metadata.methods.all()), 0)
def test_delete_resource_types_orig(self): self.assertEqual(len(self.tool_res.metadata.res_types.all()), 0) resource.create_metadata_element(self.tool_res.short_id, 'ToolResourceType', tool_res_type=self.resourcetypes1) self.assertEqual(len(self.tool_res.metadata.res_types.all()), 1) self.assertEqual(self.tool_res.metadata.res_types.all()[0].tool_res_type, self.resourcetypes1) m = self.tool_res.metadata.res_types.filter(tool_res_type=self.resourcetypes1)[0] resource.delete_metadata_element(self.tool_res.short_id, 'ToolResourceType', m.id) self.assertEqual(len(self.tool_res.metadata.res_types.all()), 0)
def test_delete_url_base_orig(self): self.assertEqual(len(self.tool_res.metadata.url_bases.all()), 0) resource.create_metadata_element(self.tool_res.short_id, 'RequestUrlBase', value=self.url1) self.assertEqual(len(self.tool_res.metadata.url_bases.all()), 1) self.assertEqual(self.tool_res.metadata.url_bases.all()[0].value, self.url1) m = self.tool_res.metadata.url_bases.filter(value=self.url1)[0] resource.delete_metadata_element(self.tool_res.short_id, 'RequestUrlBase', m.id) self.assertEqual(len(self.tool_res.metadata.url_bases.all()), 0)
def test_delete_version_orig(self): self.assertEqual(len(self.tool_res.metadata.versions.all()), 0) resource.create_metadata_element(self.tool_res.short_id, 'ToolVersion', value=self.version1) self.assertEqual(len(self.tool_res.metadata.versions.all()), 1) self.assertEqual(self.tool_res.metadata.versions.all()[0].value, self.version1) m = self.tool_res.metadata.versions.filter(value=self.version1)[0] resource.delete_metadata_element(self.tool_res.short_id, 'ToolVersion', m.id) self.assertEqual(len(self.tool_res.metadata.versions.all()), 0)
def test_update_quality_control_level(self): self.assertEqual(len(self.refts_res.metadata.quality_levels.all()), 0) resource.create_metadata_element(self.refts_res.short_id, 'QualityControlLevel', value='test quality level') self.assertEqual(len(self.refts_res.metadata.quality_levels.all()), 1) self.assertEqual(self.refts_res.metadata.quality_levels.all()[0].value, 'test quality level') q = self.refts_res.metadata.quality_levels.filter(value='test quality level')[0] resource.update_metadata_element(self.refts_res.short_id, 'QualityControlLevel', q.id, value='updated value') self.assertEqual(self.refts_res.metadata.quality_levels.all()[0].value, 'updated value')
def test_delete_fee_orig(self): self.assertEqual(len(self.tool_res.metadata.fees.all()), 0) resource.create_metadata_element(self.tool_res.short_id, 'Fee', description=self.desc1, value=self.value1) self.assertEqual(len(self.tool_res.metadata.fees.all()), 1) self.assertEqual(self.tool_res.metadata.fees.all()[0].description, self.desc1) self.assertEqual(self.tool_res.metadata.fees.all()[0].value, self.value1) m = self.tool_res.metadata.fees.filter(description=self.desc1)[0] resource.delete_metadata_element(self.tool_res.short_id, 'Fee', m.id) self.assertEqual(len(self.tool_res.metadata.fees.all()), 0)
def test_two_authors_comma(self): # add a creator element resource.create_metadata_element(self.res.short_id, 'creator', name='Smith, John') citation = self.res.get_citation() hs_identifier = self.res.metadata.identifiers.all().filter(name="hydroShareIdentifier")[0] hs_url = hs_identifier.url hs_date = str(date.today().year) correct_citation = 'Creator_LastName, C., ' \ 'J. Smith ({}). Generic resource, HydroShare, {}'.format(hs_date, hs_url) self.assertEqual(citation, correct_citation)
def test_agg_types(self): # set url launching pattern for aggregations metadata = [{'requesturlbaseaggregation': { 'value': 'https://www.google.com?agg_path=${HS_AGG_PATH}'}}] self.resWebApp.metadata.update(metadata, self.user) self.assertEqual(RequestUrlBaseAggregation.objects.all().count(), 1) # set web app to launch for geo raster self.resWebApp.metadata.update(metadata, self.user) resource.create_metadata_element(self.resWebApp.short_id, 'SupportedAggTypes', supported_agg_types=['GeoRasterLogicalFile']) self.assertEqual(1, SupportedAggTypes.objects.all().count()) # add a geo raster aggregation to the resource open_file = open(self.test_file_path.format("small_logan.tif"), 'r') resource_file_add_process(resource=self.resComposite, files=(open_file,), user=self.user) # setup the web app to be launched by the resource url = '/resource/' + self.resComposite.short_id + '/' request = self.factory.get(url) request.user = self.user self.assertEqual(self.resWebApp.extra_metadata, {}) self.resWebApp.extra_metadata = {tool_app_key: 'test-app-value'} self.resWebApp.save() self.assertNotEqual(self.resWebApp.extra_metadata, {}) self.assertEqual(self.resWebApp.extra_metadata[tool_app_key], 'test-app-value') self.assertEqual(self.resComposite.extra_metadata, {}) self.resComposite.extra_metadata = {tool_app_key: 'test-app-value'} self.resComposite.save() self.assertNotEqual(self.resComposite.extra_metadata, {}) self.assertEqual(self.resComposite.extra_metadata[tool_app_key], 'test-app-value') url = '/resource/' + self.resComposite.short_id + '/' request = self.factory.get(url) request.user = self.user # get the web tools and ensure agg_types is there relevant_tools = resource_level_tool_urls(self.resComposite, request) self.assertIsNotNone(relevant_tools, msg='relevant_tools should not be None with appkey ' 'matching') tc = relevant_tools['resource_level_app_counter'] self.assertEqual(0, tc) tl = relevant_tools['tool_list'][0] self.assertEqual(self.resWebApp.short_id, tl['res_id']) self.assertFalse(tl['approved']) self.assertTrue(tl['openwithlist']) self.assertEqual('GeoRasterLogicalFile', tl['agg_types']) self.assertEqual('', tl['file_extensions'])
def test_script_res_specific_metadata(self): ####################### # Class: ScriptSpecificMetadata ####################### # no ScriptSpecificMetadata obj self.assertEqual(ScriptSpecificMetadata.objects.all().count(), 0) # create 1 ScriptSpecificMetadata obj with required params resource.create_metadata_element( self.resScript.short_id, 'ScriptSpecificMetadata', scriptLanguage='R', languageVersion='3.5', scriptVersion='1.0', scriptDependencies='None', scriptReleaseDate='2015-12-01 00:00', scriptCodeRepository='http://www.google.com') self.assertEqual(ScriptSpecificMetadata.objects.all().count(), 1) # may not create additional instance of ScriptSpecificMetadata with self.assertRaises(Exception): resource.create_metadata_element( self.resScript.short_id, 'ScriptSpecificMetadata', scriptLanguage='R', languageVersion='3.5', scriptVersion='1.0', scriptDependencies='None', scriptReleaseDate='12/01/2015', scriptCodeRepository='http://www.google.com') self.assertEqual(ScriptSpecificMetadata.objects.all().count(), 1) # update existing meta resource.update_metadata_element( self.resScript.short_id, 'ScriptSpecificMetadata', element_id=ScriptSpecificMetadata.objects.first().id, scriptLanguage='python', languageVersion='2.7') self.assertEqual(ScriptSpecificMetadata.objects.first().scriptLanguage, 'python') self.assertEqual( ScriptSpecificMetadata.objects.first().languageVersion, '2.7') # delete ScriptSpecificMetadata obj resource.delete_metadata_element( self.resScript.short_id, 'ScriptSpecificMetadata', element_id=ScriptSpecificMetadata.objects.first().id) self.assertEqual(ScriptSpecificMetadata.objects.all().count(), 0)
def test_two_authors_multiple_first_and_last_names_no_comma(self): # add a creator element resource.create_metadata_element(self.res.short_id, 'creator', name='John Mason Jingle Smith William') citation = self.res.get_citation() hs_identifier = self.res.metadata.identifiers.all().filter(name="hydroShareIdentifier")[0] hs_url = hs_identifier.url hs_date = str(date.today().year) correct_citation = 'Creator_LastName, C., ' \ 'J. M. J. S. William ' \ '({}). Generic resource, HydroShare, {}'.format(hs_date, hs_url) self.assertEqual(citation, correct_citation)
def test_two_authors_and_organization(self): # add a creator element resource.create_metadata_element(self.res.short_id, 'creator', name='Smith William, John Mason Jingle') resource.create_metadata_element(self.res.short_id, 'creator', organization='U.S. Geological Survey') citation = self.res.get_citation() hs_identifier = self.res.metadata.identifiers.all().filter(name="hydroShareIdentifier")[0] hs_url = hs_identifier.url hs_date = str(date.today().year) correct_citation = 'Creator_LastName, C., ' \ 'J. M. J. Smith William, ' \ 'U.S. Geological Survey ' \ '({}). Generic resource, HydroShare, {}'.format(hs_date, hs_url) self.assertEqual(citation, correct_citation)
def test_script_res_specific_metadata(self): ####################### # Class: ScriptSpecificMetadata ####################### # no ScriptSpecificMetadata obj self.assertEqual(ScriptSpecificMetadata.objects.all().count(), 0) # create 1 ScriptSpecificMetadata obj with required params resource.create_metadata_element(self.resScript.short_id, 'ScriptSpecificMetadata', scriptLanguage='R', languageVersion='3.5', scriptVersion='1.0', scriptDependencies='None', scriptReleaseDate='2015-12-01 00:00', scriptCodeRepository='http://www.google.com') self.assertEqual(ScriptSpecificMetadata.objects.all().count(), 1) # may not create additional instance of ScriptSpecificMetadata with self.assertRaises(Exception): resource.create_metadata_element(self.resScript.short_id, 'ScriptSpecificMetadata', scriptLanguage='R', languageVersion='3.5', scriptVersion='1.0', scriptDependencies='None', scriptReleaseDate='12/01/2015', scriptCodeRepository='http://www.google.com') self.assertEqual(ScriptSpecificMetadata.objects.all().count(), 1) # update existing meta resource.update_metadata_element(self.resScript.short_id, 'ScriptSpecificMetadata', element_id=ScriptSpecificMetadata.objects.first().id, scriptLanguage='python', languageVersion='2.7') self.assertEqual(ScriptSpecificMetadata.objects.first().scriptLanguage, 'python') self.assertEqual(ScriptSpecificMetadata.objects.first().languageVersion, '2.7') # delete ScriptSpecificMetadata obj resource.delete_metadata_element(self.resScript.short_id, 'ScriptSpecificMetadata', element_id=ScriptSpecificMetadata.objects.first().id) self.assertEqual(ScriptSpecificMetadata.objects.all().count(), 0)
def test_create_quality_control_level_duplicate(self): self.assertEqual(len(self.refts_res.metadata.quality_levels.all()), 0) self.assertRaises(ValidationError, resource.create_metadata_element( self.refts_res.short_id, 'QualityControlLevel', value='test quality level'))
def test_create_quality_control_level_orig(self): self.assertEqual(len(self.refts_res.metadata.quality_levels.all()), 0) resource.create_metadata_element(self.refts_res.short_id, 'QualityControlLevel', value='test quality level') self.assertEqual(len(self.refts_res.metadata.quality_levels.all()), 1) self.assertEqual(self.refts_res.metadata.quality_levels.all()[0].value, 'test quality level')
def test_geo_feature_res_specific_metadata(self): # originalcoverage # no OriginalCoverage obj self.assertEqual(OriginalCoverage.objects.all().count(), 0) # create OriginalCoverage obj without a required para: southlimit with self.assertRaises(Exception): resource.create_metadata_element(self.resGeoFeature.short_id, 'originalcoverage', northlimit='1', eastlimit='2', southlimit='3') # no OriginalCoverage obj self.assertEqual(OriginalCoverage.objects.all().count(), 0) # create 1 OriginalCoverage obj with required para resource.create_metadata_element(self.resGeoFeature.short_id, 'originalcoverage', northlimit='1', eastlimit='2', southlimit='3', westlimit='4') self.assertEqual(OriginalCoverage.objects.all().count(), 1) # may not create any more OriginalCoverage with self.assertRaises(Exception): resource.create_metadata_element(self.resGeoFeature.short_id, 'originalcoverage', northlimit='1', eastlimit='2', southlimit='3', westlimit='4') self.assertEqual(OriginalCoverage.objects.all().count(), 1) # update existing meta resource.update_metadata_element(self.resGeoFeature.short_id, 'originalcoverage', element_id=OriginalCoverage.objects.first().id, northlimit='11', eastlimit='22', southlimit='33', westlimit='44', projection_string='projection_string1', projection_name='projection_name1', datum='datum1', unit='unit1') self.assertEqual(OriginalCoverage.objects.first().unit, 'unit1') # delete OriginalCoverage obj resource.delete_metadata_element(self.resGeoFeature.short_id, 'originalcoverage', element_id=OriginalCoverage.objects.first().id) self.assertEqual(OriginalCoverage.objects.all().count(), 0) # GeometryInformation # no GeometryInformation obj self.assertEqual(GeometryInformation.objects.all().count(), 0) # no GeometryInformation obj self.assertEqual(GeometryInformation.objects.all().count(), 0) # create 1 GeometryInformation obj with required para resource.create_metadata_element(self.resGeoFeature.short_id, 'GeometryInformation', featureCount='1', geometryType='Polygon_test') self.assertEqual(GeometryInformation.objects.all().count(), 1) # may not create any more GeometryInformation with self.assertRaises(Exception): resource.create_metadata_element(self.resGeoFeature.short_id, 'GeometryInformation', featureCount='1', geometryType='Polygon_test') # update existing meta resource.update_metadata_element(self.resGeoFeature.short_id, 'GeometryInformation', element_id=GeometryInformation.objects.first().id, featureCount='2', geometryType='Point_test') self.assertEqual(GeometryInformation.objects.first().geometryType, 'Point_test') self.assertEqual(GeometryInformation.objects.first().featureCount, 2) # delete GeometryInformation obj resource.delete_metadata_element(self.resGeoFeature.short_id, 'GeometryInformation', element_id=GeometryInformation.objects.first().id) self.assertEqual(GeometryInformation.objects.all().count(), 0) # FieldInformation # no FieldInformation obj self.assertEqual(FieldInformation.objects.all().count(), 0) # no FieldInformation obj self.assertEqual(FieldInformation.objects.all().count(), 0) # create 1 FieldInformation obj with required para resource.create_metadata_element(self.resGeoFeature.short_id, 'FieldInformation', fieldName='fieldName1', fieldType='fieldType1') self.assertEqual(FieldInformation.objects.all().count(), 1) resource.create_metadata_element(self.resGeoFeature.short_id, 'FieldInformation', fieldName='fieldName2', fieldType='fieldType2') self.assertEqual(FieldInformation.objects.all().count(), 2) # update existing meta field_info_obj_list = FieldInformation.objects.filter(fieldName='fieldName1') self.assertEqual(field_info_obj_list.count(), 1) field_1_ele_id_old = field_info_obj_list[0].id resource.update_metadata_element(self.resGeoFeature.short_id, 'FieldInformation', element_id=field_1_ele_id_old, fieldName='fieldName1_new', fieldType='fieldType1_new') field_info_obj_list = FieldInformation.objects.filter(fieldName='fieldName1_new') self.assertEqual(field_info_obj_list.count(), 1) field_1_ele_id_new = field_info_obj_list[0].id # ele_id should not change self.assertEqual(field_1_ele_id_new, field_1_ele_id_old) # old value is gone field_info_obj_list = FieldInformation.objects.filter(fieldName='fieldName1') self.assertEqual(field_info_obj_list.count(), 0) field_info_obj_list = FieldInformation.objects.filter(fieldName='fieldName2') self.assertEqual(field_info_obj_list.count(), 1) field_2_ele_id_old = field_info_obj_list[0].id self.assertEqual(FieldInformation.objects.all().count(), 2) # delete FieldInformation obj resource.delete_metadata_element(self.resGeoFeature.short_id, 'FieldInformation', element_id=field_1_ele_id_old) self.assertEqual(FieldInformation.objects.all().count(), 1) field_info_obj_list = FieldInformation.objects.filter(fieldName='fieldName1_new') self.assertEqual(field_info_obj_list.count(), 0) field_info_obj_list = FieldInformation.objects.filter(fieldName='fieldName2') self.assertEqual(field_info_obj_list.count(), 1) resource.delete_metadata_element(self.resGeoFeature.short_id, 'FieldInformation', element_id=field_2_ele_id_old) self.assertEqual(FieldInformation.objects.all().count(), 0) self.resGeoFeature.delete()
def test_geo_feature_basic_metadata(self): # add another creator with all sub_elements cr_name = 'Creator A' cr_des = 'http://hydroshare.org/user/001' cr_org = "BYU" cr_email = '*****@*****.**' cr_address = "Provo, UT, USA" cr_phone = '123-456-7890' cr_homepage = 'http://home.byu.edu/' resource.create_metadata_element(self.resGeoFeature.short_id, 'creator', name=cr_name, description=cr_des, organization=cr_org, email=cr_email, address=cr_address, phone=cr_phone, homepage=cr_homepage, identifiers={'ORCID': 'https://orcid.org/john', 'ResearchGateID': 'https://www.researchgate.net/john'}) # add another creator with only the name resource.create_metadata_element(self.resGeoFeature.short_id, 'creator', name='Creator B') # test adding a contributor with all sub_elements con_name = 'Contributor A' con_des = 'http://hydroshare.org/user/002' con_org = "BYU" con_email = '*****@*****.**' con_address = "Provo, UT, USA" con_phone = '123-456-7890' con_homepage = 'http://usu.edu/homepage/009' resource.create_metadata_element(self.resGeoFeature.short_id, 'contributor', name=con_name, description=con_des, organization=con_org, email=con_email, address=con_address, phone=con_phone, homepage=con_homepage, identifiers={'ORCID': 'https://orcid.org/john', 'ResearchGateID': 'https://www.researchgate.net/john'}) # add another creator with only the name resource.create_metadata_element(self.resGeoFeature.short_id, 'contributor', name='Contributor B') # add a period type coverage value_dict = {'name': 'Name for period coverage', 'start': '1/1/2015', 'end': '12/31/2015'} resource.create_metadata_element(self.resGeoFeature.short_id, 'coverage', type='period', value=value_dict) # add a point type coverage value_dict = {'name': 'Name for box coverage', 'northlimit': '80', 'eastlimit': '130', 'southlimit': '70', 'westlimit': '120'} value_dict["projection"] = "WGS 84 EPSG:4326" value_dict["units"] = "Decimal degrees" resource.create_metadata_element(self.resGeoFeature.short_id, 'coverage', type='box', value=value_dict) # add date of type 'valid' resource.create_metadata_element(self.resGeoFeature.short_id, 'date', type='valid', start_date=parser.parse('1/1/2012'), end_date=parser.parse('12/31/2012')) # add a format element format = 'shp' resource.create_metadata_element(self.resGeoFeature.short_id, 'format', value=format) # add a relation element of uri type resource.create_metadata_element(self.resGeoFeature.short_id, 'relation', type='isPartOf', value='http://hydroshare.org/resource/001') # add another relation element of non-uri type resource.create_metadata_element(self.resGeoFeature.short_id, 'relation', type='isDataFor', value='This resource is for another resource') # add a source element of uri type resource.create_metadata_element(self.resGeoFeature.short_id, 'source', derived_from='http://hydroshare.org/resource/0002') # add a subject element resource.create_metadata_element(self.resGeoFeature.short_id, 'subject', value='sub-1') # add another subject element resource.create_metadata_element(self.resGeoFeature.short_id, 'subject', value='sub-2') self.resGeoFeature.delete()
def test_metadata(self): # add a type element resource.create_metadata_element(self.resTimeSeries.short_id, 'type', url="http://hydroshare.org/netcdf") # add another creator with all sub_elements cr_name = 'Mike Sundar' cr_des = 'http://hydroshare.org/user/001' cr_org = "USU" cr_email = '*****@*****.**' cr_address = "11 River Drive, Logan UT-84321, USA" cr_phone = '435-567-0989' cr_homepage = 'http://usu.edu/homepage/001' cr_res_id = 'http://research.org/001' cr_res_gate_id = 'http://research-gate.org/001' resource.create_metadata_element(self.resTimeSeries.short_id, 'creator', name=cr_name, description=cr_des, organization=cr_org, email=cr_email, address=cr_address, phone=cr_phone, homepage=cr_homepage, researcherID=cr_res_id, researchGateID=cr_res_gate_id) # add another creator with only the name resource.create_metadata_element(self.resTimeSeries.short_id, 'creator', name='Lisa Holley') #test adding a contributor with all sub_elements con_name = 'Sujan Peterson' con_des = 'http://hydroshare.org/user/002' con_org = "USU" con_email = '*****@*****.**' con_address = "101 Center St, Logan UT-84321, USA" con_phone = '435-567-3245' con_homepage = 'http://usu.edu/homepage/009' con_res_id = 'http://research.org/009' con_res_gate_id = 'http://research-gate.org/009' resource.create_metadata_element(self.resTimeSeries.short_id, 'contributor', name=con_name, description=con_des, organization=con_org, email=con_email, address=con_address, phone=con_phone, homepage=con_homepage, researcherID=con_res_id, researchGateID=con_res_gate_id) # add another creator with only the name resource.create_metadata_element(self.resTimeSeries.short_id, 'contributor', name='Andrew Smith') # add a period type coverage # add a period type coverage value_dict = { 'name': 'Name for period coverage', 'start': '1/1/2000', 'end': '12/12/2012' } resource.create_metadata_element(self.resTimeSeries.short_id, 'coverage', type='period', value=value_dict) # add a point type coverage value_dict = { 'name': 'Name for point coverage', 'east': '56.45678', 'north': '12.6789' } resource.create_metadata_element(self.resTimeSeries.short_id, 'coverage', type='point', value=value_dict) # add date of type 'valid' resource.create_metadata_element(self.resTimeSeries.short_id, 'date', type='valid', start_date='8/10/2011', end_date='8/11/2012') # add a format element format_nc = 'netcdf' resource.create_metadata_element(self.resTimeSeries.short_id, 'format', value=format_nc) # add 'DOI' identifier #resource.create_metadata_element(self.resTimeSeries.short_id,'identifier', name='DOI', url="http://dx.doi.org/001") # add a language element resource.create_metadata_element(self.resTimeSeries.short_id, 'language', code='eng') # add 'Publisher' element original_file_name = 'original.txt' original_file = open(original_file_name, 'w') original_file.write("original text") original_file.close() original_file = open(original_file_name, 'r') # add the file to the resource hydroshare.add_resource_files(self.resTimeSeries.short_id, original_file) resource.create_metadata_element(self.resTimeSeries.short_id, 'publisher', name="HydroShare", url="http://hydroshare.org") # add a relation element of uri type resource.create_metadata_element( self.resTimeSeries.short_id, 'relation', type='isPartOf', value='http://hydroshare.org/resource/001') # add another relation element of non-uri type resource.create_metadata_element( self.resTimeSeries.short_id, 'relation', type='isDataFor', value='This resource is for another resource') # add a source element of uri type resource.create_metadata_element( self.resTimeSeries.short_id, 'source', derived_from='http://hydroshare.org/resource/0002') # add a rights element resource.create_metadata_element( self.resTimeSeries.short_id, 'rights', statement='This is the rights statement for this resource', url='http://rights.ord/001') # add a subject element resource.create_metadata_element(self.resTimeSeries.short_id, 'subject', value='sub-1') # add another subject element resource.create_metadata_element(self.resTimeSeries.short_id, 'subject', value='sub-2') # add time series specific metadata elements self.resTimeSeries.metadata.create_element( 'site', site_code='LR_WaterLab_AA', site_name='Logan River at the Utah Water Research Laboratory ' 'west bridge', elevation_m=1414, elevation_datum='EGM96', site_type='Stream') self.resTimeSeries.metadata.create_element( 'variable', variable_code='ODO', variable_name='Oxygen, dissolved', variable_type='Concentration', no_data_value=-9999, variable_definition= 'Concentration of oxygen gas dissolved in water.', speciation='Not Applicable') self.resTimeSeries.metadata.create_element( 'method', method_code=59, method_name='Optical DO', method_type='Instrument deployment', method_description='Dissolved oxygen concentration measured ' 'optically using a YSI EXO multi-parameter water ' 'quality sonde.', method_link='http://www.exowater.com') exp_text = """Raw and unprocessed data and data products that have not undergone quality control. Depending on the variable, data type, and data transmission system, raw data may be available within seconds or minutes after the measurements have been made. Examples include real time precipitation, streamflow and water quality measurements.""" self.resTimeSeries.metadata.create_element('processinglevel', processing_level_code=0, definition='Raw data', explanation=exp_text) self.resTimeSeries.metadata.create_element( 'timeseriesresult', units_type='Concentration', units_name='milligrams per liter', units_abbreviation='mg/L', status='Complete', sample_medium='Surface water', value_count=11283, aggregation_statistics="Average") print self.resTimeSeries.metadata.get_xml() print(bad)
def test_geo_feature_basic_metadata(self): # add another creator with all sub_elements cr_name = 'Creator A' cr_des = 'http://hydroshare.org/user/001' cr_org = "BYU" cr_email = '*****@*****.**' cr_address = "Provo, UT, USA" cr_phone = '123-456-7890' cr_homepage = 'http://home.byu.edu/' cr_res_id = 'http://research.org/001' cr_res_gate_id = 'http://research-gate.org/001' resource.create_metadata_element(self.resGeoFeature.short_id, 'creator', name=cr_name, description=cr_des, organization=cr_org, email=cr_email, address=cr_address, phone=cr_phone, homepage=cr_homepage, profile_links=[{'type': 'researchID', 'url': cr_res_id}, {'type': 'researchGateID', 'url': cr_res_gate_id}]) # add another creator with only the name resource.create_metadata_element(self.resGeoFeature.short_id, 'creator', name='Creator B') # test adding a contributor with all sub_elements con_name = 'Contributor A' con_des = 'http://hydroshare.org/user/002' con_org = "BYU" con_email = '*****@*****.**' con_address = "Provo, UT, USA" con_phone = '123-456-7890' con_homepage = 'http://usu.edu/homepage/009' con_res_id = 'http://research.org/009' con_res_gate_id = 'http://research-gate.org/009' resource.create_metadata_element(self.resGeoFeature.short_id, 'contributor', name=con_name, description=con_des, organization=con_org, email=con_email, address=con_address, phone=con_phone, homepage=con_homepage, profile_links=[{'type': 'researchID', 'url': con_res_id}, {'type': 'researchGateID', 'url': con_res_gate_id}]) # add another creator with only the name resource.create_metadata_element(self.resGeoFeature.short_id, 'contributor', name='Contributor B') # add a period type coverage value_dict = {'name': 'Name for period coverage', 'start': '1/1/2015', 'end': '12/31/2015'} resource.create_metadata_element(self.resGeoFeature.short_id, 'coverage', type='period', value=value_dict) # add a point type coverage value_dict = {'name': 'Name for box coverage', 'northlimit': '80', 'eastlimit': '130', 'southlimit': '70', 'westlimit': '120'} value_dict["projection"] = "WGS 84 EPSG:4326" value_dict["units"] = "Decimal degrees" resource.create_metadata_element(self.resGeoFeature.short_id, 'coverage', type='box', value=value_dict) # add date of type 'valid' resource.create_metadata_element(self.resGeoFeature.short_id, 'date', type='valid', start_date=parser.parse('1/1/2012'), end_date=parser.parse('12/31/2012')) # add a format element format = 'shp' resource.create_metadata_element(self.resGeoFeature.short_id, 'format', value=format) # add a relation element of uri type resource.create_metadata_element(self.resGeoFeature.short_id, 'relation', type='isPartOf', value='http://hydroshare.org/resource/001') # add another relation element of non-uri type resource.create_metadata_element(self.resGeoFeature.short_id, 'relation', type='isDataFor', value='This resource is for another resource') # add a source element of uri type resource.create_metadata_element(self.resGeoFeature.short_id, 'source', derived_from='http://hydroshare.org/resource/0002') # add a subject element resource.create_metadata_element(self.resGeoFeature.short_id, 'subject', value='sub-1') # add another subject element resource.create_metadata_element(self.resGeoFeature.short_id, 'subject', value='sub-2') self.resGeoFeature.delete()
def test_web_app_res_specific_metadata(self): # Class: RequestUrlBase # no RequestUrlBase obj self.assertEqual(RequestUrlBase.objects.all().count(), 0) # create 1 RequestUrlBase obj with required params resource.create_metadata_element(self.resWebApp.short_id, 'RequestUrlBase', value='https://www.google.com') self.assertEqual(RequestUrlBase.objects.all().count(), 1) # may not create additional instance of RequestUrlBase with self.assertRaises(Exception): resource.create_metadata_element(self.resWebApp.short_id, 'RequestUrlBase', value='https://www.facebook.com') self.assertEqual(RequestUrlBase.objects.all().count(), 1) # update existing meta resource.update_metadata_element( self.resWebApp.short_id, 'RequestUrlBase', element_id=RequestUrlBase.objects.first().id, value='https://www.yahoo.com') self.assertEqual(RequestUrlBase.objects.first().value, 'https://www.yahoo.com') # delete RequestUrlBase obj resource.delete_metadata_element( self.resWebApp.short_id, 'RequestUrlBase', element_id=RequestUrlBase.objects.first().id) self.assertEqual(RequestUrlBase.objects.all().count(), 0) # Class: ToolVersion # verify no ToolVersion obj self.assertEqual(ToolVersion.objects.all().count(), 0) # no ToolVersion obj self.assertEqual(ToolVersion.objects.all().count(), 0) # create 1 ToolVersion obj with required params resource.create_metadata_element(self.resWebApp.short_id, 'ToolVersion', value='1.0') self.assertEqual(ToolVersion.objects.all().count(), 1) # may not create additional instance of ToolVersion with self.assertRaises(Exception): resource.create_metadata_element(self.resWebApp.short_id, 'ToolVersion', value='2.0') self.assertEqual(ToolVersion.objects.all().count(), 1) # update existing meta resource.update_metadata_element( self.resWebApp.short_id, 'ToolVersion', element_id=ToolVersion.objects.first().id, value='3.0') self.assertEqual(ToolVersion.objects.first().value, '3.0') # delete ToolVersion obj resource.delete_metadata_element( self.resWebApp.short_id, 'ToolVersion', element_id=ToolVersion.objects.first().id) self.assertEqual(ToolVersion.objects.all().count(), 0) # Class: SupportedResTypes # no SupportedResTypes obj self.assertEqual(SupportedResTypes.objects.all().count(), 0) # create 2 SupportedResTypes obj with required params resource.create_metadata_element( self.resWebApp.short_id, 'SupportedResTypes', supported_res_types=['NetcdfResource']) resource.create_metadata_element( self.resWebApp.short_id, 'SupportedResTypes', supported_res_types=['NetcdfResource']) self.assertEqual(SupportedResTypes.objects.all().count(), 2) # update existing meta resource.update_metadata_element( self.resWebApp.short_id, 'SupportedResTypes', element_id=SupportedResTypes.objects.first().id, supported_res_types=['TimeSeriesResource']) self.assertEqual( SupportedResTypes.objects.first().supported_res_types.all() [0].description, 'TimeSeriesResource') # try to delete 1st SupportedResTypes obj with self.assertRaises(Exception): resource.delete_metadata_element( self.resWebApp.short_id, 'SupportedResTypes', element_id=SupportedResTypes.objects.first().id) self.assertEqual(SupportedResTypes.objects.all().count(), 2) # Class: ToolIcon # verify no ToolIcon obj self.assertEqual(ToolIcon.objects.all().count(), 0) # no ToolIcon obj self.assertEqual(ToolIcon.objects.all().count(), 0) # create 1 ToolIcon obj with required params resource.create_metadata_element( self.resWebApp.short_id, 'ToolIcon', value='https://www.hydroshare.org/static/img/logo-sm.png') self.assertEqual(ToolIcon.objects.all().count(), 1) # may not create additional instance of ToolIcon with self.assertRaises(Exception): resource.\ create_metadata_element(self.resWebApp.short_id, 'ToolIcon', value='https://www.hydroshare.org/static/img/logo-sm.png') self.assertEqual(ToolIcon.objects.all().count(), 1) # update existing meta resource.\ update_metadata_element(self.resWebApp.short_id, 'ToolIcon', element_id=ToolIcon.objects.first().id, value='https://www.hydroshare.org/static/img/logo-sm.png') self.assertEqual(ToolIcon.objects.first().value, 'https://www.hydroshare.org/static/img/logo-sm.png') # delete ToolIcon obj resource.delete_metadata_element( self.resWebApp.short_id, 'ToolIcon', element_id=ToolIcon.objects.first().id) self.assertEqual(ToolIcon.objects.all().count(), 0) # Class: AppHomePageUrl # verify no AppHomePageUrl obj self.assertEqual(AppHomePageUrl.objects.all().count(), 0) # create 1 AppHomePageUrl obj with required params resource.create_metadata_element(self.resWebApp.short_id, 'AppHomePageUrl', value='https://my_web_app.com') self.assertEqual(AppHomePageUrl.objects.all().count(), 1) # may not create additional instance of AppHomePageUrl with self.assertRaises(Exception): resource.create_metadata_element(self.resWebApp.short_id, 'AppHomePageUrl', value='https://my_web_app_2.com') self.assertEqual(AppHomePageUrl.objects.all().count(), 1) # update existing meta resource.update_metadata_element( self.resWebApp.short_id, 'AppHomePageUrl', element_id=AppHomePageUrl.objects.first().id, value='http://my_web_app_3.com') self.assertEqual(AppHomePageUrl.objects.first().value, 'http://my_web_app_3.com') # delete AppHomePageUrl obj resource.delete_metadata_element( self.resWebApp.short_id, 'AppHomePageUrl', element_id=AppHomePageUrl.objects.first().id) self.assertEqual(AppHomePageUrl.objects.all().count(), 0)
def test_netcdf_metadata(self): # add a type element resource.create_metadata_element(self.resNetCDF.short_id, 'type', url="http://hydroshare.org/netcdf") # add another creator with all sub_elements cr_name = 'Mike Sundar' cr_des = 'http://hydroshare.org/user/001' cr_org = "USU" cr_email = '*****@*****.**' cr_address = "11 River Drive, Logan UT-84321, USA" cr_phone = '435-567-0989' cr_homepage = 'http://usu.edu/homepage/001' cr_res_id = 'http://research.org/001' cr_res_gate_id = 'http://research-gate.org/001' resource.create_metadata_element(self.resNetCDF.short_id, 'creator', name=cr_name, description=cr_des, organization=cr_org, email=cr_email, address=cr_address, phone=cr_phone, homepage=cr_homepage, researcherID=cr_res_id, researchGateID=cr_res_gate_id) # add another creator with only the name resource.create_metadata_element(self.resNetCDF.short_id, 'creator', name='Lisa Holley') #test adding a contributor with all sub_elements con_name = 'Sujan Peterson' con_des = 'http://hydroshare.org/user/002' con_org = "USU" con_email = '*****@*****.**' con_address = "101 Center St, Logan UT-84321, USA" con_phone = '435-567-3245' con_homepage = 'http://usu.edu/homepage/009' con_res_id = 'http://research.org/009' con_res_gate_id = 'http://research-gate.org/009' resource.create_metadata_element(self.resNetCDF.short_id, 'contributor', name=con_name, description=con_des, organization=con_org, email=con_email, address=con_address, phone=con_phone, homepage=con_homepage, researcherID=con_res_id, researchGateID=con_res_gate_id) # add another creator with only the name resource.create_metadata_element(self.resNetCDF.short_id, 'contributor', name='Andrew Smith') # add a period type coverage # add a period type coverage value_dict = { 'name': 'Name for period coverage', 'start': '1/1/2000', 'end': '12/12/2012' } resource.create_metadata_element(self.resNetCDF.short_id, 'coverage', type='period', value=value_dict) # add a point type coverage value_dict = { 'name': 'Name for point coverage', 'east': '56.45678', 'north': '12.6789' } resource.create_metadata_element(self.resNetCDF.short_id, 'coverage', type='point', value=value_dict) # add date of type 'valid' resource.create_metadata_element(self.resNetCDF.short_id, 'date', type='valid', start_date='8/10/2011', end_date='8/11/2012') # add a format element format_nc = 'netcdf' resource.create_metadata_element(self.resNetCDF.short_id, 'format', value=format_nc) # add 'DOI' identifier #resource.create_metadata_element(self.resNetCDF.short_id,'identifier', name='DOI', url="http://dx.doi.org/001") # add a language element resource.create_metadata_element(self.resNetCDF.short_id, 'language', code='eng') # add 'Publisher' element original_file_name = 'original.txt' original_file = open(original_file_name, 'w') original_file.write("original text") original_file.close() original_file = open(original_file_name, 'r') # add the file to the resource hydroshare.add_resource_files(self.resNetCDF.short_id, original_file) resource.create_metadata_element(self.resNetCDF.short_id, 'publisher', name="HydroShare", url="http://hydroshare.org") # add a relation element of uri type resource.create_metadata_element( self.resNetCDF.short_id, 'relation', type='isPartOf', value='http://hydroshare.org/resource/001') # add another relation element of non-uri type resource.create_metadata_element( self.resNetCDF.short_id, 'relation', type='isDataFor', value='This resource is for another resource') # add a source element of uri type resource.create_metadata_element( self.resNetCDF.short_id, 'source', derived_from='http://hydroshare.org/resource/0002') # add a rights element resource.create_metadata_element( self.resNetCDF.short_id, 'rights', statement='This is the rights statement for this resource', url='http://rights.ord/001') # add a subject element resource.create_metadata_element(self.resNetCDF.short_id, 'subject', value='sub-1') # add another subject element resource.create_metadata_element(self.resNetCDF.short_id, 'subject', value='sub-2') # add a netcdf specific element (variable) resource.create_metadata_element(self.resNetCDF.short_id, 'variable', name='temp', unit='deg C', type='float', shape='shape_unknown') print self.resNetCDF.metadata.get_xml() print(bad)
def test_web_app_res_specific_metadata(self): # Class: RequestUrlBase # no RequestUrlBase obj self.assertEqual(RequestUrlBase.objects.all().count(), 0) # create 1 RequestUrlBase obj with required params resource.create_metadata_element(self.resWebApp.short_id, 'RequestUrlBase', value='https://www.google.com') self.assertEqual(RequestUrlBase.objects.all().count(), 1) # may not create additional instance of RequestUrlBase with self.assertRaises(Exception): resource.create_metadata_element(self.resWebApp.short_id, 'RequestUrlBase', value='https://www.facebook.com') self.assertEqual(RequestUrlBase.objects.all().count(), 1) # update existing meta resource.update_metadata_element(self.resWebApp.short_id, 'RequestUrlBase', element_id=RequestUrlBase.objects.first().id, value='https://www.yahoo.com') self.assertEqual(RequestUrlBase.objects.first().value, 'https://www.yahoo.com') # delete RequestUrlBase obj resource.delete_metadata_element(self.resWebApp.short_id, 'RequestUrlBase', element_id=RequestUrlBase.objects.first().id) self.assertEqual(RequestUrlBase.objects.all().count(), 0) # Class: ToolVersion # verify no ToolVersion obj self.assertEqual(ToolVersion.objects.all().count(), 0) # no ToolVersion obj self.assertEqual(ToolVersion.objects.all().count(), 0) # create 1 ToolVersion obj with required params resource.create_metadata_element(self.resWebApp.short_id, 'ToolVersion', value='1.0') self.assertEqual(ToolVersion.objects.all().count(), 1) # may not create additional instance of ToolVersion with self.assertRaises(Exception): resource.create_metadata_element(self.resWebApp.short_id, 'ToolVersion', value='2.0') self.assertEqual(ToolVersion.objects.all().count(), 1) # update existing meta resource.update_metadata_element(self.resWebApp.short_id, 'ToolVersion', element_id=ToolVersion.objects.first().id, value='3.0') self.assertEqual(ToolVersion.objects.first().value, '3.0') # delete ToolVersion obj resource.delete_metadata_element(self.resWebApp.short_id, 'ToolVersion', element_id=ToolVersion.objects.first().id) self.assertEqual(ToolVersion.objects.all().count(), 0) # Class: SupportedResTypes # no SupportedResTypes obj self.assertEqual(SupportedResTypes.objects.all().count(), 0) # create 1 SupportedResTypes obj with required params resource.create_metadata_element(self.resWebApp.short_id, 'SupportedResTypes', supported_res_types=['NetcdfResource']) self.assertEqual(SupportedResTypes.objects.all().count(), 1) # Try creating the 2nd SupportedResTypes obj with required params with self.assertRaises(Exception): resource.create_metadata_element(self.resWebApp.short_id, 'SupportedResTypes', supported_res_types=['NetcdfResource']) self.assertEqual(SupportedResTypes.objects.all().count(), 1) # update existing meta resource.update_metadata_element(self.resWebApp.short_id, 'SupportedResTypes', element_id=SupportedResTypes.objects.first().id, supported_res_types=['TimeSeriesResource']) self.assertEqual(SupportedResTypes.objects.first().supported_res_types.all()[0].description, 'TimeSeriesResource') # try to delete 1st SupportedResTypes obj with self.assertRaises(Exception): resource.delete_metadata_element(self.resWebApp.short_id, 'SupportedResTypes', element_id=SupportedResTypes.objects.first().id) self.assertEqual(SupportedResTypes.objects.all().count(), 1) # Class: ToolIcon # verify no ToolIcon obj self.assertEqual(ToolIcon.objects.all().count(), 0) # no ToolIcon obj self.assertEqual(ToolIcon.objects.all().count(), 0) # create 1 ToolIcon obj with required params resource.create_metadata_element(self.resWebApp.short_id, 'ToolIcon', value='https://www.hydroshare.org/static/img/logo-sm.png') self.assertEqual(ToolIcon.objects.all().count(), 1) # may not create additional instance of ToolIcon with self.assertRaises(Exception): resource. \ create_metadata_element(self.resWebApp.short_id, 'ToolIcon', value='https://www.hydroshare.org/static/img/logo-sm.png') self.assertEqual(ToolIcon.objects.all().count(), 1) # update existing meta resource. \ update_metadata_element(self.resWebApp.short_id, 'ToolIcon', element_id=ToolIcon.objects.first().id, value='https://www.hydroshare.org/static/img/logo-sm.png') self.assertEqual(ToolIcon.objects.first().value, 'https://www.hydroshare.org/static/img/logo-sm.png') # delete ToolIcon obj resource.delete_metadata_element(self.resWebApp.short_id, 'ToolIcon', element_id=ToolIcon.objects.first().id) self.assertEqual(ToolIcon.objects.all().count(), 0) # Class: AppHomePageUrl # verify no AppHomePageUrl obj self.assertEqual(AppHomePageUrl.objects.all().count(), 0) # create 1 AppHomePageUrl obj with required params resource.create_metadata_element(self.resWebApp.short_id, 'AppHomePageUrl', value='https://my_web_app.com') self.assertEqual(AppHomePageUrl.objects.all().count(), 1) # may not create additional instance of AppHomePageUrl with self.assertRaises(Exception): resource.create_metadata_element(self.resWebApp.short_id, 'AppHomePageUrl', value='https://my_web_app_2.com') self.assertEqual(AppHomePageUrl.objects.all().count(), 1) # update existing meta resource.update_metadata_element(self.resWebApp.short_id, 'AppHomePageUrl', element_id=AppHomePageUrl.objects.first().id, value='http://my_web_app_3.com') self.assertEqual(AppHomePageUrl.objects.first().value, 'http://my_web_app_3.com') # delete AppHomePageUrl obj resource.delete_metadata_element(self.resWebApp.short_id, 'AppHomePageUrl', element_id=AppHomePageUrl.objects.first().id) self.assertEqual(AppHomePageUrl.objects.all().count(), 0)
def test_netcdf_metadata(self): # add a type element resource.create_metadata_element(self.resNetCDF.short_id, 'type', url="http://hydroshare.org/netcdf") # add another creator with all sub_elements cr_name = 'Mike Sundar' cr_des = 'http://hydroshare.org/user/001' cr_org = "USU" cr_email = '*****@*****.**' cr_address = "11 River Drive, Logan UT-84321, USA" cr_phone = '435-567-0989' cr_homepage = 'http://usu.edu/homepage/001' cr_res_id = 'http://research.org/001' cr_res_gate_id = 'http://research-gate.org/001' resource.create_metadata_element(self.resNetCDF.short_id,'creator', name=cr_name, description=cr_des, organization=cr_org, email=cr_email, address=cr_address, phone=cr_phone, homepage=cr_homepage, researcherID=cr_res_id, researchGateID=cr_res_gate_id) # add another creator with only the name resource.create_metadata_element(self.resNetCDF.short_id,'creator', name='Lisa Holley') #test adding a contributor with all sub_elements con_name = 'Sujan Peterson' con_des = 'http://hydroshare.org/user/002' con_org = "USU" con_email = '*****@*****.**' con_address = "101 Center St, Logan UT-84321, USA" con_phone = '435-567-3245' con_homepage = 'http://usu.edu/homepage/009' con_res_id = 'http://research.org/009' con_res_gate_id = 'http://research-gate.org/009' resource.create_metadata_element(self.resNetCDF.short_id,'contributor', name=con_name, description=con_des, organization=con_org, email=con_email, address=con_address, phone=con_phone, homepage=con_homepage, researcherID=con_res_id, researchGateID=con_res_gate_id) # add another creator with only the name resource.create_metadata_element(self.resNetCDF.short_id,'contributor', name='Andrew Smith') # add a period type coverage # add a period type coverage value_dict = {'name':'Name for period coverage' , 'start':'1/1/2000', 'end':'12/12/2012'} resource.create_metadata_element(self.resNetCDF.short_id,'coverage', type='period', value=value_dict) # add a point type coverage value_dict = {'name':'Name for point coverage', 'east':'56.45678', 'north':'12.6789'} resource.create_metadata_element(self.resNetCDF.short_id,'coverage', type='point', value=value_dict) # add date of type 'valid' resource.create_metadata_element(self.resNetCDF.short_id,'date', type='valid', start_date='8/10/2011', end_date='8/11/2012') # add a format element format_nc = 'netcdf' resource.create_metadata_element(self.resNetCDF.short_id,'format', value=format_nc) # add 'DOI' identifier #resource.create_metadata_element(self.resNetCDF.short_id,'identifier', name='DOI', url="http://dx.doi.org/001") # add a language element resource.create_metadata_element(self.resNetCDF.short_id,'language', code='eng') # add 'Publisher' element original_file_name = 'original.txt' original_file = open(original_file_name, 'w') original_file.write("original text") original_file.close() original_file = open(original_file_name, 'r') # add the file to the resource hydroshare.add_resource_files(self.resNetCDF.short_id, original_file) resource.create_metadata_element(self.resNetCDF.short_id,'publisher', name="HydroShare", url="http://hydroshare.org") # add a relation element of uri type resource.create_metadata_element(self.resNetCDF.short_id,'relation', type='isPartOf', value='http://hydroshare.org/resource/001') # add another relation element of non-uri type resource.create_metadata_element(self.resNetCDF.short_id,'relation', type='isDataFor', value='This resource is for another resource') # add a source element of uri type resource.create_metadata_element(self.resNetCDF.short_id,'source', derived_from='http://hydroshare.org/resource/0002') # add a rights element resource.create_metadata_element(self.resNetCDF.short_id,'rights', statement='This is the rights statement for this resource', url='http://rights.ord/001') # add a subject element resource.create_metadata_element(self.resNetCDF.short_id,'subject', value='sub-1') # add another subject element resource.create_metadata_element(self.resNetCDF.short_id,'subject', value='sub-2') # add a netcdf specific element (variable) resource.create_metadata_element(self.resNetCDF.short_id,'variable', name='temp', unit='deg C', type='float', shape='shape_unknown') print self.resNetCDF.metadata.get_xml() print(bad)
def test_create_refurl_orig(self): self.assertEqual(len(self.refts_res.metadata.methods.all()), 0) resource.create_metadata_element(self.refts_res.short_id, 'ReferenceURL', value='www.google.com', type='SOAP') self.assertEqual(len(self.refts_res.metadata.referenceURLs.all()), 1) self.assertEqual(self.refts_res.metadata.referenceURLs.all()[0].value, 'www.google.com') self.assertEqual(self.refts_res.metadata.referenceURLs.all()[0].type, 'SOAP')
def test_metadata(self): # add a type element resource.create_metadata_element(self.resTimeSeries.short_id, 'type', url="http://hydroshare.org/netcdf") # add another creator with all sub_elements cr_name = 'Mike Sundar' cr_des = 'http://hydroshare.org/user/001' cr_org = "USU" cr_email = '*****@*****.**' cr_address = "11 River Drive, Logan UT-84321, USA" cr_phone = '435-567-0989' cr_homepage = 'http://usu.edu/homepage/001' cr_res_id = 'http://research.org/001' cr_res_gate_id = 'http://research-gate.org/001' resource.create_metadata_element(self.resTimeSeries.short_id,'creator', name=cr_name, description=cr_des, organization=cr_org, email=cr_email, address=cr_address, phone=cr_phone, homepage=cr_homepage, researcherID=cr_res_id, researchGateID=cr_res_gate_id) # add another creator with only the name resource.create_metadata_element(self.resTimeSeries.short_id,'creator', name='Lisa Holley') #test adding a contributor with all sub_elements con_name = 'Sujan Peterson' con_des = 'http://hydroshare.org/user/002' con_org = "USU" con_email = '*****@*****.**' con_address = "101 Center St, Logan UT-84321, USA" con_phone = '435-567-3245' con_homepage = 'http://usu.edu/homepage/009' con_res_id = 'http://research.org/009' con_res_gate_id = 'http://research-gate.org/009' resource.create_metadata_element(self.resTimeSeries.short_id,'contributor', name=con_name, description=con_des, organization=con_org, email=con_email, address=con_address, phone=con_phone, homepage=con_homepage, researcherID=con_res_id, researchGateID=con_res_gate_id) # add another creator with only the name resource.create_metadata_element(self.resTimeSeries.short_id,'contributor', name='Andrew Smith') # add a period type coverage # add a period type coverage value_dict = {'name':'Name for period coverage' , 'start':'1/1/2000', 'end':'12/12/2012'} resource.create_metadata_element(self.resTimeSeries.short_id,'coverage', type='period', value=value_dict) # add a point type coverage value_dict = {'name':'Name for point coverage', 'east':'56.45678', 'north':'12.6789'} resource.create_metadata_element(self.resTimeSeries.short_id,'coverage', type='point', value=value_dict) # add date of type 'valid' resource.create_metadata_element(self.resTimeSeries.short_id,'date', type='valid', start_date='8/10/2011', end_date='8/11/2012') # add a format element format_nc = 'netcdf' resource.create_metadata_element(self.resTimeSeries.short_id,'format', value=format_nc) # add 'DOI' identifier #resource.create_metadata_element(self.resTimeSeries.short_id,'identifier', name='DOI', url="http://dx.doi.org/001") # add a language element resource.create_metadata_element(self.resTimeSeries.short_id,'language', code='eng') # add 'Publisher' element original_file_name = 'original.txt' original_file = open(original_file_name, 'w') original_file.write("original text") original_file.close() original_file = open(original_file_name, 'r') # add the file to the resource hydroshare.add_resource_files(self.resTimeSeries.short_id, original_file) resource.create_metadata_element(self.resTimeSeries.short_id,'publisher', name="HydroShare", url="http://hydroshare.org") # add a relation element of uri type resource.create_metadata_element(self.resTimeSeries.short_id,'relation', type='isPartOf', value='http://hydroshare.org/resource/001') # add another relation element of non-uri type resource.create_metadata_element(self.resTimeSeries.short_id,'relation', type='isDataFor', value='This resource is for another resource') # add a source element of uri type resource.create_metadata_element(self.resTimeSeries.short_id,'source', derived_from='http://hydroshare.org/resource/0002') # add a rights element resource.create_metadata_element(self.resTimeSeries.short_id,'rights', statement='This is the rights statement for this resource', url='http://rights.ord/001') # add a subject element resource.create_metadata_element(self.resTimeSeries.short_id,'subject', value='sub-1') # add another subject element resource.create_metadata_element(self.resTimeSeries.short_id,'subject', value='sub-2') # add time series specific metadata elements self.resTimeSeries.metadata.create_element('site', site_code='LR_WaterLab_AA', site_name='Logan River at the Utah Water Research Laboratory ' 'west bridge', elevation_m=1414, elevation_datum='EGM96', site_type='Stream') self.resTimeSeries.metadata.create_element('variable', variable_code='ODO', variable_name='Oxygen, dissolved', variable_type='Concentration', no_data_value=-9999, variable_definition='Concentration of oxygen gas dissolved in water.', speciation='Not Applicable') self.resTimeSeries.metadata.create_element('method', method_code=59, method_name='Optical DO', method_type='Instrument deployment', method_description='Dissolved oxygen concentration measured ' 'optically using a YSI EXO multi-parameter water ' 'quality sonde.', method_link='http://www.exowater.com') exp_text = """Raw and unprocessed data and data products that have not undergone quality control. Depending on the variable, data type, and data transmission system, raw data may be available within seconds or minutes after the measurements have been made. Examples include real time precipitation, streamflow and water quality measurements.""" self.resTimeSeries.metadata.create_element('processinglevel', processing_level_code=0, definition='Raw data', explanation=exp_text) self.resTimeSeries.metadata.create_element('timeseriesresult', units_type='Concentration', units_name='milligrams per liter', units_abbreviation='mg/L', status='Complete', sample_medium='Surface water', value_count=11283, aggregation_statistics="Average") print self.resTimeSeries.metadata.get_xml() print(bad)