def test_update_science_metadata_coverage_type_box(self):
metadata_dict = [
{'coverage': {'type': 'period', 'value': {'name': 'Name for period coverage', 'start': '1/1/2000',
'end': '12/12/2012'}}},
{'coverage': {'type': 'box', 'value': {'name': 'Name for box coverage', 'northlimit': '56.45678',
'eastlimit': '130.6789', 'southlimit': '16.45678',
'westlimit': '16.6789', 'units': 'decimal deg'}}},
]
# there should be 0 coverage elements
self.assertEqual(self.res.metadata.coverages.all().count(), 0, msg="Number of coverages not equal to 0.")
# now add the 2 coverage elements by updating metadata
hydroshare.update_science_metadata(pk=self.res.short_id, metadata=metadata_dict)
# there should be now 2 coverage elements after the update
self.assertEqual(self.res.metadata.coverages.all().count(), 2, msg="Number of coverages not equal to 2.")
self.assertEqual(self.res.metadata.coverages.filter(type='period').count(), 1,
msg="Number of coverage element of type period is not equal to 1.")
self.assertEqual(self.res.metadata.coverages.filter(type='box').count(), 1,
msg="Number of coverage element of type box is not equal to 1.")
cov_box = self.res.metadata.coverages.filter(type='box').first()
self.assertEquals(cov_box.value['name'], 'Name for box coverage')
self.assertEquals(cov_box.value['northlimit'], 56.45678)
self.assertEquals(cov_box.value['eastlimit'], 130.6789)
self.assertEquals(cov_box.value['southlimit'], 16.45678)
self.assertEquals(cov_box.value['westlimit'], 16.6789)
self.assertEquals(cov_box.value['units'], 'decimal deg')
def put(self, request, pk):
# Update science metadata
resource, _, _ = view_utils.authorize(
request, pk,
needed_permission=ACTION_TO_AUTHORIZE.EDIT_RESOURCE)
metadata = []
put_data = request.data.copy()
# convert the QueryDict to dict
if isinstance(put_data, QueryDict):
put_data = put_data.dict()
try:
resource.metadata.parse_for_bulk_update(put_data, metadata)
hydroshare.update_science_metadata(pk=pk, metadata=metadata, user=request.user)
except Exception as ex:
error_msg = {
'resource': "Resource metadata update failed: %s, %s"
% (ex.__class__, ex.message)
}
raise ValidationError(detail=error_msg)
resource = hydroshare.get_resource_by_shortkey(shortkey=pk)
serializer = resource.metadata.serializer
return Response(data=serializer.data, status=status.HTTP_202_ACCEPTED)
def test_update_science_metadata_coverage_type_box(self):
metadata_dict = [
{'coverage': {'type': 'period', 'value': {'name': 'Name for period coverage', 'start': '1/1/2000',
'end': '12/12/2012'}}},
{'coverage': {'type': 'box', 'value': {'name': 'Name for box coverage', 'northlimit': '56.45678',
'eastlimit': '130.6789', 'southlimit': '16.45678',
'westlimit': '16.6789', 'units': 'decimal deg'}}},
]
# there should be 0 coverage elements
self.assertEqual(self.res.metadata.coverages.all().count(), 0, msg="Number of coverages not equal to 0.")
# now add the 2 coverage elements by updating metadata
hydroshare.update_science_metadata(pk=self.res.short_id, metadata=metadata_dict,
user=self.user)
# there should be now 2 coverage elements after the update
self.assertEqual(self.res.metadata.coverages.all().count(), 2, msg="Number of coverages not equal to 2.")
self.assertEqual(self.res.metadata.coverages.filter(type='period').count(), 1,
msg="Number of coverage element of type period is not equal to 1.")
self.assertEqual(self.res.metadata.coverages.filter(type='box').count(), 1,
msg="Number of coverage element of type box is not equal to 1.")
cov_box = self.res.metadata.coverages.filter(type='box').first()
self.assertEquals(cov_box.value['name'], 'Name for box coverage')
self.assertEquals(cov_box.value['northlimit'], 56.45678)
self.assertEquals(cov_box.value['eastlimit'], 130.6789)
self.assertEquals(cov_box.value['southlimit'], 16.45678)
self.assertEquals(cov_box.value['westlimit'], 16.6789)
self.assertEquals(cov_box.value['units'], 'decimal deg')
def put(self, request, pk):
# Update science metadata
resource, _, _ = view_utils.authorize(
request, pk,
needed_permission=ACTION_TO_AUTHORIZE.EDIT_RESOURCE)
metadata = []
put_data = request.data.copy()
# convert the QueryDict to dict
if isinstance(put_data, QueryDict):
put_data = put_data.dict()
try:
resource.metadata.parse_for_bulk_update(put_data, metadata)
hydroshare.update_science_metadata(pk=pk, metadata=metadata, user=request.user)
except Exception as ex:
error_msg = {
'resource': "Resource metadata update failed: %s, %s"
% (ex.__class__, ex.message)
}
raise ValidationError(detail=error_msg)
resource = hydroshare.get_resource_by_shortkey(shortkey=pk)
serializer = resource.metadata.serializer
return Response(data=serializer.data, status=status.HTTP_202_ACCEPTED)
def test_update_science_metadata(self):
d_m = [{
'term':'SRC',
'qualifier': 'BYU Archives',
'content': 'Archive may be found at HBLL Library at HBLL:S102948'
},
{
'term':'REP',
'qualifier': "Dr. Nielson's work",
'content': 'replaced in 2003'
},
{
'term':'PBL',
'qualifier': 'Dr. Ames',
'content': 'Published 2001'
}]
hydroshare.update_science_metadata(self.res.short_id, dublin_metadata=d_m)
for t in ('SRC','REP', 'PBL'):
self.assertTrue(any(QDCE.objects.filter(term=t)))
self.assertEqual(QDCE.objects.all(), QDCE.objects.filter(content_object=res))
def put(self, request, pk):
# Update science metadata
view_utils.authorize(
request, pk, needed_permission=ACTION_TO_AUTHORIZE.EDIT_RESOURCE)
metadata = []
put_data = request.data.copy()
keys_to_update = put_data.keys()
try:
if 'title' in keys_to_update:
metadata.append({"title": {"value": put_data.pop('title')}})
if 'creators' in keys_to_update:
for creator in put_data.pop('creators'):
metadata.append({"creator": creator})
if 'contributors' in keys_to_update:
for contributor in put_data.pop('contributors'):
metadata.append({"contributor": contributor})
if 'coverages' in keys_to_update:
for coverage in put_data.pop('coverages'):
metadata.append({"coverage": coverage})
if 'dates' in keys_to_update:
for date in put_data.pop('dates'):
metadata.append({"date": date})
if 'description' in keys_to_update:
metadata.append(
{"description": {
"abstract": put_data.pop('description')
}})
if 'language' in keys_to_update:
metadata.append(
{"language": {
"code": put_data.pop('language')
}})
if 'rights' in keys_to_update:
metadata.append(
{"rights": {
"statement": put_data.pop('rights')
}})
if 'sources' in keys_to_update:
for source in put_data.pop('sources'):
metadata.append({"source": source})
if 'subjects' in keys_to_update:
for subject in put_data.pop('subjects'):
metadata.append({"subject": {"value": subject['value']}})
hydroshare.update_science_metadata(pk=pk,
metadata=metadata,
user=request.user)
except Exception as ex:
error_msg = {
'resource':
"Resource metadata update failed: %s, %s" %
(ex.__class__, ex.message)
}
raise ValidationError(detail=error_msg)
resource = hydroshare.get_resource_by_shortkey(shortkey=pk)
serializer = CoreMetaDataSerializer(resource.metadata)
return Response(data=serializer.data, status=status.HTTP_202_ACCEPTED)
def test_update_science_metadata(self):
# add these new metadata elements
metadata_dict = [
{
'title': {
'value': 'Updated Resource Title'
}
},
{
'description': {
'abstract': 'Updated Resource Abstract'
}
},
{
'date': {
'type': 'valid',
'start_date': '1/26/2016',
'end_date': '12/31/2016'
}
},
{
'date': {
'type': 'created',
'start_date': '1/26/2016'
}
}, # will be ignored without error
{
'date': {
'type': 'modified',
'start_date': '1/26/2016'
}
}, # will be ignored without error
{
'date': {
'type': 'published',
'start_date': '1/26/2016'
}
}, # will be ignored without error
{
'date': {
'type': 'available',
'start_date': '1/26/2016'
}
}, # will be ignored without error
{
'creator': {
'name': 'John Smith',
'email': '*****@*****.**'
}
},
{
'creator': {
'name': 'Lisa Molley',
'email': '*****@*****.**'
}
},
{
'contributor': {
'name': 'Kelvin Marshal',
'email': '*****@*****.**',
'organization': 'Utah State University',
'identifiers': {
'ORCID': 'https://orcid.org/john',
'ResearchGateID': 'https://www.researchgate.net/john'
}
}
},
{
'coverage': {
'type': 'period',
'value': {
'name': 'Name for period coverage',
'start': '1/1/2000',
'end': '12/12/2012'
}
}
},
{
'coverage': {
'type': 'point',
'value': {
'name': 'Name for point coverage',
'east': '56.45678',
'north': '12.6789',
'units': 'decimal deg'
}
}
},
{
'format': {
'value': 'txt/csv'
}
}, # will be ignored without error
{
'format': {
'value': 'zip'
}
}, # will be ignored without error
{
'identifier': {
'name': 'someIdentifier',
'url': "http://some.org/002"
}
},
{
'identifier': {
'name': 'hydroShareIdentifier',
'url': "http://hydroshare.org/001"
}
}, # will be ignored
{
'language': {
'code': 'fre'
}
},
{
'relation': {
'type': 'isPartOf',
'value': 'http://hydroshare.org/resource/001'
}
},
{
'rights': {
'statement':
'This is the rights statement for this resource',
'url': 'http://rights.ord/001'
}
},
{
'source': {
'derived_from': 'http://hydroshare.org/resource/0001'
}
},
{
'subject': {
'value': 'sub-1'
}
},
{
'subject': {
'value': 'sub-2'
}
},
]
hydroshare.update_science_metadata(pk=self.res.short_id,
metadata=metadata_dict,
user=self.user)
# check that the title element got updated
self.assertEqual(self.res.metadata.title.value,
'Updated Resource Title',
msg='Resource title did not match')
# check that description element (abstract) got updated
self.assertEqual(self.res.metadata.description.abstract,
'Updated Resource Abstract',
msg='Resource abstract did not match')
# the following 3 date elements should exist
self.assertEqual(self.res.metadata.dates.all().count(),
3,
msg="Number of date elements not equal to 3.")
self.assertIn('created',
[dt.type for dt in self.res.metadata.dates.all()],
msg="Date element type 'Created' does not exist")
self.assertIn('modified',
[dt.type for dt in self.res.metadata.dates.all()],
msg="Date element type 'Modified' does not exist")
self.assertIn('valid',
[dt.type for dt in self.res.metadata.dates.all()],
msg="Date element type 'Valid' does not exist")
valid_date = self.res.metadata.dates.filter(type='valid').first()
self.assertEqual(valid_date.start_date.date(),
parser.parse('1/26/2016').date())
self.assertEqual(valid_date.end_date.date(),
parser.parse('12/31/2016').date())
# number of creators at this point should be 2 (the original creator of the resource get deleted as part of
# this update)
self.assertEqual(self.res.metadata.creators.all().count(),
2,
msg='Number of creators not equal to 3')
self.assertIn('John Smith',
[cr.name for cr in self.res.metadata.creators.all()],
msg="Creator 'John Smith' was not found")
self.assertIn('Lisa Molley',
[cr.name for cr in self.res.metadata.creators.all()],
msg="Creator 'Lisa Molley' was not found")
self.assertIn('*****@*****.**',
[cr.email for cr in self.res.metadata.creators.all()],
msg="Creator email '*****@*****.**' was not found")
self.assertIn('*****@*****.**',
[cr.email for cr in self.res.metadata.creators.all()],
msg="Creator email '*****@*****.**' was not found")
# number of contributors at this point should be 1
self.assertEqual(self.res.metadata.contributors.all().count(),
1,
msg='Number of contributors not equal to 1')
contributor = self.res.metadata.contributors.first()
self.assertEqual(contributor.name, 'Kelvin Marshal')
self.assertEqual(contributor.email, '*****@*****.**')
self.assertEqual(contributor.organization, 'Utah State University')
for name, link in list(contributor.identifiers.items()):
self.assertIn(name, ['ResearchGateID', 'ORCID'])
self.assertIn(link, [
'https://orcid.org/john', 'https://www.researchgate.net/john'
])
# there should be now 2 coverage elements
self.assertEqual(self.res.metadata.coverages.all().count(),
2,
msg="Number of coverages not equal to 2.")
# there should 1 coverage element of type 'period'
self.assertEqual(
self.res.metadata.coverages.filter(type='period').count(),
1,
msg="Number of coverage elements of type 'period is not equal to 1"
)
# there should 1 coverage element of type 'point'
self.assertEqual(
self.res.metadata.coverages.filter(type='point').count(),
1,
msg="Number of coverage elements of type 'point' is not equal to 1"
)
cov_period = self.res.metadata.coverages.filter(type='period').first()
self.assertEqual(cov_period.value['name'], 'Name for period coverage')
self.assertEqual(
parser.parse(cov_period.value['start']).date(),
parser.parse('1/1/2000').date())
self.assertEqual(
parser.parse(cov_period.value['end']).date(),
parser.parse('12/12/2012').date())
cov_point = self.res.metadata.coverages.filter(type='point').first()
self.assertEqual(cov_point.value['name'], 'Name for point coverage')
self.assertEqual(cov_point.value['east'], 56.45678)
self.assertEqual(cov_point.value['north'], 12.6789)
self.assertEqual(cov_point.value['units'], 'decimal deg')
# there should be no format elements
self.assertEqual(self.res.metadata.formats.all().count(),
0,
msg="Number of format elements not equal to 0.")
# there should be now 2 identifier elements ( 1 we are creating her + 1 auto generated at the time of
# resource creation)
self.assertEqual(self.res.metadata.identifiers.all().count(),
2,
msg="Number of identifier elements not equal to 1.")
# this the one we added as part of the update
some_identifier = self.res.metadata.identifiers.filter(
name='someIdentifier').first()
self.assertEqual(some_identifier.url, "http://some.org/002")
self.assertEqual(self.res.metadata.language.code,
'fre',
msg="Resource has a language that is not French.")
self.assertEqual(self.res.metadata.relations.all().count(),
1,
msg="Number of source elements is not equal to 1")
relation = self.res.metadata.relations.filter(type='isPartOf').first()
self.assertEqual(relation.value, 'http://hydroshare.org/resource/001')
self.assertEqual(self.res.metadata.rights.statement,
'This is the rights statement for this resource',
msg="Statement of rights did not match.")
self.assertEqual(self.res.metadata.rights.url,
'http://rights.ord/001',
msg="URL of rights did not match.")
self.assertEqual(self.res.metadata.sources.all().count(),
1,
msg="Number of sources is not equal to 1.")
self.assertIn(
'http://hydroshare.org/resource/0001',
[src.derived_from for src in self.res.metadata.sources.all()],
msg="Source element with derived from a value of %s does not exist."
% 'http://hydroshare.org/resource/0001')
# there should be 2 subject elements for this resource
self.assertEqual(self.res.metadata.subjects.all().count(),
2,
msg="Number of subject elements found not be 1.")
self.assertIn(
'sub-1', [sub.value for sub in self.res.metadata.subjects.all()],
msg="Subject element with value of %s does not exist." % 'sub-1')
self.assertIn(
'sub-2', [sub.value for sub in self.res.metadata.subjects.all()],
msg="Subject element with value of %s does not exist." % 'sub-1')
def test_update_collection_coverages(self):
# collection has no coverages metadata by default
self.assertEqual(self.resCollection.metadata.coverages.count(), 0)
# add 2 resources without coverage metadata to collection
self.resCollection.resources.add(self.resGen1)
self.resCollection.resources.add(self.resGeoFeature)
self.assertEqual(self.resCollection.resources.count(), 2)
# calculate overall coverages
_update_collection_coverages(self.resCollection)
# no collection coverage
self.assertEqual(self.resCollection.metadata.coverages.count(), 0)
# update resGen1 coverage
metadata_dict = [{'coverage': {'type': 'period', 'value':
{'name': 'Name for period coverage',
'start': '1/1/2016', 'end': '12/31/2016'}}}, ]
update_science_metadata(pk=self.resGen1.short_id, metadata=metadata_dict, user=self.user1)
self.assertEqual(self.resGen1.metadata.coverages.count(), 1)
# calculate overall coverages
_update_collection_coverages(self.resCollection)
# collection should have 1 coverage metadata: period
self.assertEqual(self.resCollection.metadata.coverages.count(), 1)
period_coverage_obj = self.resCollection.metadata.coverages.all()[0]
self.assertEqual(period_coverage_obj.type.lower(), 'period')
self.assertEqual(parser.parse(period_coverage_obj.value['start'].lower()),
parser.parse('1/1/2016'))
self.assertEqual(parser.parse(period_coverage_obj.value['end'].lower()),
parser.parse('12/31/2016'))
# update resGeoFeature coverage
metadata_dict = [{'coverage': {'type': 'point', 'value':
{'name': 'Name for point coverage', 'east': '-20',
'north': '10', 'units': 'decimal deg'}}}, ]
update_science_metadata(pk=self.resGeoFeature.short_id, metadata=metadata_dict,
user=self.user1)
self.assertEqual(self.resGeoFeature.metadata.coverages.count(), 1)
# calculate overall coverages
_update_collection_coverages(self.resCollection)
# collection should have 2 coverage metadata: period and point
self.assertEqual(self.resCollection.metadata.coverages.count(), 2)
# test period
period_qs = self.resCollection.metadata.coverages.all().filter(type='period')
self.assertEqual(period_qs.count(), 1)
self.assertEqual(parser.parse(period_qs[0].value['start'].lower()),
parser.parse('1/1/2016'))
self.assertEqual(parser.parse(period_qs[0].value['end'].lower()),
parser.parse('12/31/2016'))
# test point
point_qs = self.resCollection.metadata.coverages.all().filter(type='point')
self.assertEqual(point_qs.count(), 1)
self.assertEqual(point_qs[0].value['east'], -20)
self.assertEqual(point_qs[0].value['north'], 10)
# add a 3rd res with period and box coverages into collection
metadata_dict = [{'coverage': {'type': 'period', 'value':
{'name': 'Name for period coverage',
'start': '1/1/2010', 'end': '6/1/2016'}}},
{'coverage': {'type': 'point', 'value':
{'name': 'Name for point coverage', 'east': '25',
'north': '-35', 'units': 'decimal deg'}}}]
update_science_metadata(pk=self.resGen2.short_id, metadata=metadata_dict, user=self.user1)
self.assertEqual(self.resGen2.metadata.coverages.count(), 2)
self.resCollection.resources.add(self.resGen2)
self.assertEqual(self.resCollection.resources.count(), 3)
# calculate overall coverages
_update_collection_coverages(self.resCollection)
self.assertEqual(self.resCollection.metadata.coverages.count(), 2)
# test period
period_qs = self.resCollection.metadata.coverages.all().filter(type='period')
self.assertEqual(period_qs.count(), 1)
self.assertEqual(parser.parse(period_qs[0].value['start'].lower()),
parser.parse('1/1/2010'))
self.assertEqual(parser.parse(period_qs[0].value['end'].lower()),
parser.parse('12/31/2016'))
# test point
point_qs = self.resCollection.metadata.coverages.all().filter(type='box')
self.assertEqual(point_qs.count(), 1)
self.assertEqual(point_qs[0].value['westlimit'], -20)
self.assertEqual(point_qs[0].value['northlimit'], 10)
self.assertEqual(point_qs[0].value['eastlimit'], 25)
self.assertEqual(point_qs[0].value['southlimit'], -35)
# test view func calculate_collection_coverages
# user 1 login
self.api_client.login(username='******', password='******')
# add 2 resources into collection
url_to_calculate_collection_coverages = \
self.url_to_calculate_collection_coverages.\
format(self.resCollection.short_id)
response = self.api_client.post(url_to_calculate_collection_coverages)
resp_json = json.loads(response.content)
self.assertEqual(resp_json["status"], "success")
self.assertEqual(len(resp_json["new_coverage_list"]), 2)
found_period = False
found_box = False
for cv in resp_json["new_coverage_list"]:
if cv["type"] == 'period':
found_period = True
self.assertEqual(parser.parse(cv['value']['start'].lower()),
parser.parse('1/1/2010'))
self.assertEqual(parser.parse(cv['value']['end'].lower()),
parser.parse('12/31/2016'))
self.assertEqual(cv['element_id_str'], '-1')
elif cv["type"] == 'box':
found_box = True
self.assertEqual(cv['value']['westlimit'], -20)
self.assertEqual(cv['value']['northlimit'], 10)
self.assertEqual(cv['value']['eastlimit'], 25)
self.assertEqual(cv['value']['southlimit'], -35)
self.assertEqual(cv['element_id_str'], '-1')
self.assertTrue(found_period)
self.assertTrue(found_box)
# remove all contained res
self.resCollection.resources.clear()
_update_collection_coverages(self.resCollection)
self.assertEqual(self.resCollection.metadata.coverages.count(), 0)
def test_update_science_metadata_pk(self):
# add these new metadata elements
metadata_dict = [
{"creator": {"name": "John Smith", "email": "*****@*****.**"}},
{"creator": {"name": "Lisa Molley", "email": "*****@*****.**"}},
{
"contributor": {
"name": "Kelvin Marshal",
"email": "*****@*****.**",
"organization": "Utah State University",
"profile_links": [{"type": "yahooProfile", "url": "http://yahoo.com/LH001"}],
}
},
{
"coverage": {
"type": "period",
"value": {"name": "Name for period coverage", "start": "1/1/2000", "end": "12/12/2012"},
}
},
{
"coverage": {
"type": "point",
"value": {"name": "Name for point coverage", "east": "56.45678", "north": "12.6789"},
}
},
{"format": {"value": "txt/csv"}},
{"format": {"value": "zip"}},
{"identifier": {"name": "someIdentifier", "url": "http://some.org/001"}},
{"language": {"code": "eng"}},
{"relation": {"type": "isPartOf", "value": "http://hydroshare.org/resource/001"}},
{"rights": {"statement": "This is the rights statement for this resource", "url": "http://rights.ord/001"}},
{"source": {"derived_from": "http://hydroshare.org/resource/0001"}},
{"subject": {"value": "sub-1"}},
{"subject": {"value": "sub-2"}},
]
hydroshare.update_science_metadata(pk=self.res.short_id, metadata=metadata_dict)
# title element is automatically added in the science metadata update api method
self.assertEqual(self.res.metadata.title.value, self.res.title, msg="resource title did not match")
# resource description element is automatically added in the science metadata update api method
self.assertEqual(self.res.metadata.description.abstract, "Test Resource")
# the following 2 date elements are automatically added in the science metadata update api method
self.assertEqual(self.res.metadata.dates.all().count(), 2, msg="Number of date elements not equal to 2.")
self.assertIn(
"created",
[dt.type for dt in self.res.metadata.dates.all()],
msg="Date element type 'Created' does not exist",
)
self.assertIn(
"modified",
[dt.type for dt in self.res.metadata.dates.all()],
msg="Date element type 'Modified' does not exist",
)
# number of creators at this point should be 3 (2 we are creating here one is automatically generated in resource creation signal
self.assertEqual(self.res.metadata.creators.all().count(), 3, msg="Number of creators not equal to 3")
self.assertIn(
"John Smith", [cr.name for cr in self.res.metadata.creators.all()], msg="Creator 'John Smith' was not found"
)
self.assertIn(
"Lisa Molley",
[cr.name for cr in self.res.metadata.creators.all()],
msg="Creator 'Lisa Molley' was not found",
)
# number of contributors at this point should be 1
self.assertEqual(self.res.metadata.contributors.all().count(), 1, msg="Number of contributors not equal to 1")
# there should be now 2 coverage elements
self.assertEqual(self.res.metadata.coverages.all().count(), 2, msg="Number of coverages not equal to 2.")
# there should be now 2 format elements
self.assertEqual(self.res.metadata.formats.all().count(), 2, msg="Number of format elements not equal to 2.")
# there should be now 2 identifier elements ( 1 we rae creating her + 1 auto generated in the resource creation signal handler)
self.assertEqual(
self.res.metadata.identifiers.all().count(), 2, msg="Number of identifier elements not equal to 1."
)
self.assertEqual(self.res.metadata.language.code, "eng", msg="Resource has a language that is not English.")
self.assertEqual(
self.res.metadata.relations.all().count(), 1, msg="Number of source elements is not equal to 1"
)
self.assertEqual(
self.res.metadata.rights.statement,
"This is the rights statement for this resource",
msg="Statement of rights did not match.",
)
self.assertEqual(self.res.metadata.rights.url, "http://rights.ord/001", msg="URL of rights did not match.")
self.assertEqual(self.res.metadata.sources.all().count(), 1, msg="Number of sources is not equal to 1.")
self.assertIn(
"http://hydroshare.org/resource/0001",
[src.derived_from for src in self.res.metadata.sources.all()],
msg="Source element with derived from avlue of %s does not exist." % "http://hydroshare.org/resource/0001",
)
# there should be 2 subject elements for this resource
self.assertEqual(self.res.metadata.subjects.all().count(), 2, msg="Number of subject elements found not be 1.")
self.assertIn(
"sub-1",
[sub.value for sub in self.res.metadata.subjects.all()],
msg="Subject element with value of %s does not exist." % "sub-1",
)
self.assertIn(
"sub-2",
[sub.value for sub in self.res.metadata.subjects.all()],
msg="Subject element with value of %s does not exist." % "sub-1",
)
def test_update_science_metadata(self):
# add these new metadata elements
metadata_dict = [
{'title': {'value': 'Updated Resource Title'}},
{'description': {'abstract': 'Updated Resource Abstract'}},
{'date': {'type': 'valid', 'start_date': '1/26/2016', 'end_date': '12/31/2016'}},
{'date': {'type': 'created', 'start_date': '1/26/2016'}}, # will be ignored without error
{'date': {'type': 'modified', 'start_date': '1/26/2016'}}, # will be ignored without error
{'date': {'type': 'published', 'start_date': '1/26/2016'}}, # will be ignored without error
{'date': {'type': 'available', 'start_date': '1/26/2016'}}, # will be ignored without error
{'creator': {'name': 'John Smith', 'email': '*****@*****.**'}},
{'creator': {'name': 'Lisa Molley', 'email': '*****@*****.**'}},
{'contributor': {'name': 'Kelvin Marshal', 'email': '*****@*****.**',
'organization': 'Utah State University',
'identifiers': {'ORCID': 'https://orcid.org/john',
'ResearchGateID': 'https://www.researchgate.net/john'}
}},
{'coverage': {'type': 'period', 'value': {'name': 'Name for period coverage', 'start': '1/1/2000',
'end': '12/12/2012'}}},
{'coverage': {'type': 'point', 'value': {'name': 'Name for point coverage', 'east': '56.45678',
'north': '12.6789', 'units': 'decimal deg'}}},
{'format': {'value': 'txt/csv'}}, # will be ignored without error
{'format': {'value': 'zip'}}, # will be ignored without error
{'identifier': {'name': 'someIdentifier', 'url': "http://some.org/002"}},
{'identifier': {'name': 'hydroShareIdentifier', 'url': "http://hydroshare.org/001"}}, # will be ignored
{'language': {'code': 'fre'}},
{'relation': {'type': 'isPartOf', 'value': 'http://hydroshare.org/resource/001'}},
{'rights': {'statement': 'This is the rights statement for this resource', 'url': 'http://rights.ord/001'}},
{'source': {'derived_from': 'http://hydroshare.org/resource/0001'}},
{'subject': {'value': 'sub-1'}},
{'subject': {'value': 'sub-2'}},
]
hydroshare.update_science_metadata(pk=self.res.short_id, metadata=metadata_dict,
user=self.user)
# check that the title element got updated
self.assertEqual(self.res.metadata.title.value, 'Updated Resource Title', msg='Resource title did not match')
# check that description element (abstract) got updated
self.assertEqual(self.res.metadata.description.abstract, 'Updated Resource Abstract',
msg='Resource abstract did not match')
# the following 3 date elements should exist
self.assertEqual(self.res.metadata.dates.all().count(), 3, msg="Number of date elements not equal to 3.")
self.assertIn('created', [dt.type for dt in self.res.metadata.dates.all()],
msg="Date element type 'Created' does not exist")
self.assertIn('modified', [dt.type for dt in self.res.metadata.dates.all()],
msg="Date element type 'Modified' does not exist")
self.assertIn('valid', [dt.type for dt in self.res.metadata.dates.all()],
msg="Date element type 'Valid' does not exist")
valid_date = self.res.metadata.dates.filter(type='valid').first()
self.assertEquals(valid_date.start_date.date(), parser.parse('1/26/2016').date())
self.assertEquals(valid_date.end_date.date(), parser.parse('12/31/2016').date())
# number of creators at this point should be 2 (the original creator of the resource get deleted as part of
# this update)
self.assertEqual(self.res.metadata.creators.all().count(), 2, msg='Number of creators not equal to 3')
self.assertIn('John Smith', [cr.name for cr in self.res.metadata.creators.all()],
msg="Creator 'John Smith' was not found")
self.assertIn('Lisa Molley', [cr.name for cr in self.res.metadata.creators.all()],
msg="Creator 'Lisa Molley' was not found")
self.assertIn('*****@*****.**', [cr.email for cr in self.res.metadata.creators.all()],
msg="Creator email '*****@*****.**' was not found")
self.assertIn('*****@*****.**', [cr.email for cr in self.res.metadata.creators.all()],
msg="Creator email '*****@*****.**' was not found")
# number of contributors at this point should be 1
self.assertEqual(self.res.metadata.contributors.all().count(), 1, msg='Number of contributors not equal to 1')
contributor = self.res.metadata.contributors.first()
self.assertEquals(contributor.name, 'Kelvin Marshal')
self.assertEquals(contributor.email, '*****@*****.**')
self.assertEquals(contributor.organization, 'Utah State University')
for name, link in contributor.identifiers.iteritems():
self.assertIn(name, ['ResearchGateID', 'ORCID'])
self.assertIn(link, ['https://orcid.org/john', 'https://www.researchgate.net/john'])
# there should be now 2 coverage elements
self.assertEqual(self.res.metadata.coverages.all().count(), 2, msg="Number of coverages not equal to 2.")
# there should 1 coverage element of type 'period'
self.assertEquals(self.res.metadata.coverages.filter(type='period').count(), 1,
msg="Number of coverage elements of type 'period is not equal to 1")
# there should 1 coverage element of type 'point'
self.assertEquals(self.res.metadata.coverages.filter(type='point').count(), 1,
msg="Number of coverage elements of type 'point' is not equal to 1")
cov_period = self.res.metadata.coverages.filter(type='period').first()
self.assertEquals(cov_period.value['name'], 'Name for period coverage')
self.assertEquals(parser.parse(cov_period.value['start']).date(), parser.parse('1/1/2000').date())
self.assertEquals(parser.parse(cov_period.value['end']).date(), parser.parse('12/12/2012').date())
cov_point = self.res.metadata.coverages.filter(type='point').first()
self.assertEquals(cov_point.value['name'], 'Name for point coverage')
self.assertEquals(cov_point.value['east'], 56.45678)
self.assertEquals(cov_point.value['north'], 12.6789)
self.assertEquals(cov_point.value['units'], 'decimal deg')
# there should be no format elements
self.assertEqual(self.res.metadata.formats.all().count(), 0, msg="Number of format elements not equal to 0.")
# there should be now 2 identifier elements ( 1 we are creating her + 1 auto generated at the time of
# resource creation)
self.assertEqual(self.res.metadata.identifiers.all().count(), 2,
msg="Number of identifier elements not equal to 1.")
# this the one we added as part of the update
some_identifier = self.res.metadata.identifiers.filter(name='someIdentifier').first()
self.assertEquals(some_identifier.url, "http://some.org/002")
self.assertEqual(self.res.metadata.language.code, 'fre', msg="Resource has a language that is not French.")
self.assertEqual(self.res.metadata.relations.all().count(), 1,
msg="Number of source elements is not equal to 1")
relation = self.res.metadata.relations.filter(type='isPartOf').first()
self.assertEquals(relation.value, 'http://hydroshare.org/resource/001')
self.assertEqual(self.res.metadata.rights.statement, 'This is the rights statement for this resource',
msg="Statement of rights did not match.")
self.assertEqual(self.res.metadata.rights.url, 'http://rights.ord/001', msg="URL of rights did not match.")
self.assertEqual(self.res.metadata.sources.all().count(), 1, msg="Number of sources is not equal to 1.")
self.assertIn('http://hydroshare.org/resource/0001',
[src.derived_from for src in self.res.metadata.sources.all()],
msg="Source element with derived from a value of %s does not exist."
% 'http://hydroshare.org/resource/0001')
# there should be 2 subject elements for this resource
self.assertEqual(self.res.metadata.subjects.all().count(), 2, msg="Number of subject elements found not be 1.")
self.assertIn('sub-1', [sub.value for sub in self.res.metadata.subjects.all()],
msg="Subject element with value of %s does not exist." % 'sub-1')
self.assertIn('sub-2', [sub.value for sub in self.res.metadata.subjects.all()],
msg="Subject element with value of %s does not exist." % 'sub-1')
def test_update_science_metadata_pk(self):
# add these new metadata elements
metadata_dict = [
{'creator': {'name':'John Smith', 'email':'*****@*****.**'}},
{'creator': {'name':'Lisa Molley', 'email':'*****@*****.**'}},
{'contributor': {'name':'Kelvin Marshal', 'email':'*****@*****.**',
'organization': 'Utah State University',
'profile_links': [{'type':'yahooProfile', 'url': 'http://yahoo.com/LH001'}]}},
{'coverage': {'type':'period', 'value':{'name':'Name for period coverage' , 'start':'1/1/2000', 'end':'12/12/2012'}}},
{'coverage': {'type':'point', 'value': {'name':'Name for point coverage', 'east':'56.45678', 'north':'12.6789'}}},
{'format': {'value': 'txt/csv'}},
{'format': {'value': 'zip'}},
{'identifier': {'name':'someIdentifier', 'url':"http://some.org/001"}},
{'language': {'code':'eng'}},
{'relation': {'type':'isPartOf', 'value':'http://hydroshare.org/resource/001'}},
{'rights': {'statement':'This is the rights statement for this resource', 'url':'http://rights.ord/001'}},
{'source': {'derived_from':'http://hydroshare.org/resource/0001'}},
{'subject': {'value':'sub-1'}},
{'subject': {'value':'sub-2'}},
]
hydroshare.update_science_metadata(pk=self.res.short_id, metadata = metadata_dict)
# title element is automatically added in the science metadata update api method
self.assertEqual(self.res.metadata.title.value, self.res.title, msg='resource title did not match')
# resource description element is automatically added in the science metadata update api method
self.assertEqual(self.res.metadata.description.abstract, 'Test Resource')
# the following 2 date elements are automatically added in the science metadata update api method
self.assertEqual(self.res.metadata.dates.all().count(), 2, msg="Number of date elements not equal to 2.")
self.assertIn('created', [dt.type for dt in self.res.metadata.dates.all()], msg="Date element type 'Created' does not exist")
self.assertIn('modified', [dt.type for dt in self.res.metadata.dates.all()], msg="Date element type 'Modified' does not exist")
# number of creators at this point should be 3 (2 we are creating here one is automatically generated in resource creation signal
self.assertEqual(self.res.metadata.creators.all().count(), 3, msg='Number of creators not equal to 3')
self.assertIn('John Smith', [cr.name for cr in self.res.metadata.creators.all()], msg="Creator 'John Smith' was not found")
self.assertIn('Lisa Molley', [cr.name for cr in self.res.metadata.creators.all()], msg="Creator 'Lisa Molley' was not found")
# number of contributors at this point should be 1
self.assertEqual(self.res.metadata.contributors.all().count(), 1, msg='Number of contributors not equal to 1')
# there should be now 2 coverage elements
self.assertEqual(self.res.metadata.coverages.all().count(), 2, msg="Number of coverages not equal to 2.")
# there should be now 2 format elements
self.assertEqual(self.res.metadata.formats.all().count(), 2, msg="Number of format elements not equal to 2.")
# there should be now 2 identifier elements ( 1 we rae creating her + 1 auto generated in the resource creation signal handler)
self.assertEqual(self.res.metadata.identifiers.all().count(), 2, msg="Number of identifier elements not equal to 1.")
self.assertEqual(self.res.metadata.language.code, 'eng', msg="Resource has a language that is not English.")
self.assertEqual(self.res.metadata.relations.all().count(), 1,
msg="Number of source elements is not equal to 1")
self.assertEqual(self.res.metadata.rights.statement, 'This is the rights statement for this resource', msg="Statement of rights did not match.")
self.assertEqual(self.res.metadata.rights.url, 'http://rights.ord/001', msg="URL of rights did not match.")
self.assertEqual(self.res.metadata.sources.all().count(), 1, msg="Number of sources is not equal to 1.")
self.assertIn('http://hydroshare.org/resource/0001',
[src.derived_from for src in self.res.metadata.sources.all()],
msg="Source element with derived from avlue of %s does not exist."
% 'http://hydroshare.org/resource/0001')
# there should be 2 subject elements for this resource
self.assertEqual(self.res.metadata.subjects.all().count(), 2, msg="Number of subject elements found not be 1.")
self.assertIn('sub-1', [sub.value for sub in self.res.metadata.subjects.all()],
msg="Subject element with value of %s does not exist." % 'sub-1')
self.assertIn('sub-2', [sub.value for sub in self.res.metadata.subjects.all()],
msg="Subject element with value of %s does not exist." % 'sub-1')
