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