def test_purgeDatastream(self):
# add a datastream that can be purged
(added, dsprofile), ds = self._add_text_datastream()
# grab datastream creation date from addDatastream result to test purge result
dsprofile_node = etree.fromstring(dsprofile)
created = dsprofile_node.xpath('string(m:dsCreateDate)', namespaces={'m': FEDORA_MANAGE_NS})
# purgeDatastream gives us back the time in a different format:
expect_created = created
if expect_created.endswith('Z'): # it does
# strip of the Z and any final zeros
expect_created = expect_created.rstrip('Z0')
# strip the decimal if it got that far
expect_created = expect_created.rstrip('.')
# and put back the Z
expect_created += 'Z'
purged, times = self.rest_api.purgeDatastream(self.pid, ds['id'],
logMessage="purging text datastream")
self.assertTrue(purged)
self.assert_(expect_created in times,
'datastream creation date should be returned in list of purged datastreams - expected %s, got %s' % \
(expect_created, times))
# log message in audit trail
xml, url = self.rest_api.getObjectXML(self.pid)
self.assert_('purging text datastream' in xml)
# datastream no longer listed
dslist, url = self.rest_api.listDatastreams(self.pid)
self.assert_('<datastream dsid="%s"' % ds['id'] not in dslist)
# NOTE: Fedora bug - attempting to purge a non-existent datastream returns 204?
#purged = self.rest_api.purgeDatastream(self.pid, "BOGUS",
# logMessage="test purging non-existent datastream")
#self.assertFalse(purged)
purged, message = self.rest_api.purgeDatastream("bogus:pid", "BOGUS",
logMessage="test purging non-existent datastream from non-existent object")
self.assertFalse(purged)
self.assert_('no path in db' in message)
# also test purging specific versions of a datastream ?
# attempt to purge a version that doesn't exist
(added, dsprofile), ds = self._add_text_datastream()
tomorrow = datetime.now(tzutc()) + timedelta(1)
success, times = self.rest_api.purgeDatastream(self.pid, ds['id'],
startDT=datetime_to_fedoratime(tomorrow),
logMessage="purging text datastream")
# no errors, no versions purged
self.assertTrue(success)
self.assertEqual('[]', times)
def getObjectProfile(self, pid, asOfDateTime=None):
"""Get top-level information aboug a single Fedora object; optionally,
retrieve information as of a particular date-time.
:param pid: object pid
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
"""
# /objects/{pid} ? [format] [asOfDateTime]
http_args = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
http_args.update(self.format_xml)
url = 'objects/%s?%s' % (pid, urlencode(http_args))
return self.read(url)
def getDatastream(self, pid, dsID, asOfDateTime=None, validateChecksum=False):
"""Get information about a single datastream on a Fedora object; optionally,
get information for the version of the datastream as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
"""
# /objects/{pid}/datastreams/{dsID} ? [asOfDateTime] [format] [validateChecksum]
http_args = {}
if validateChecksum:
http_args['validateChecksum'] = validateChecksum
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
http_args.update(self.format_xml)
uri = 'objects/%s/datastreams/%s' % (pid, dsID) + '?' + urlencode(http_args)
return self.read(uri)
def getDatastreamDissemination(self, pid, dsID, asOfDateTime=None):
"""Get a single datastream on a Fedora object; optionally, get the version
as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
"""
# TODO: Note that this loads the entire datastream content into
# memory as a Python string. This will suck for very large
# datastreams. Eventually we need to either modify this function or
# else add another to return self.open(), allowing users to stream
# the result in a with block.
# /objects/{pid}/datastreams/{dsID}/content ? [asOfDateTime] [download]
http_args = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
url = 'objects/%s/datastreams/%s/content?%s' % (pid, dsID, urlencode(http_args))
return self.read(url)
def to_xml(self, dt):
return datetime_to_fedoratime(dt)
