class TestEvo(TestROEVOSupport.TestROEVOSupport):
TEST_RO_ID = "ro-manager-evo-test-ro"
TEST_SNAPHOT_RO_ID = "ro-manager-test-evo-snaphot-ro"
TEST_SNAPHOT_ID = "ro-manager-test-evo-snaphot"
TEST_CREATED_RO_ID = ""
def setUp(self):
super(TestEvo, self).setUp()
self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN)
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
(status, reason, rouri, manifest) = self.rosrs.createRO(self.TEST_RO_ID,
"Test RO for ROEVO", "Test Creator", "2012-09-06")
self.TEST_CREATED_RO_ID = rouri
return
def tearDown(self):
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
(status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID+"/")
(status, reason) = self.rosrs.deleteRO(self.TEST_CREATED_RO_ID)
super(TestEvo, self).tearDown()
return
def testSnapshot(self):
rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, ro_test_config.ROSRS_ACCESS_TOKEN)
(copy_status, snapshot_uri) = self.createSnapshot(self.TEST_CREATED_RO_ID, self.TEST_SNAPHOT_ID, False)
assert copy_status == "DONE"
(status, reason, data, evo_type) = rosrs.getROEvolution(snapshot_uri)
assert evo_type == 3
self.freeze(snapshot_uri)
(status, reason, data, evo_type) = rosrs.getROEvolution(snapshot_uri)
assert evo_type == 1
(status, reason) = self.rosrs.deleteRO(self.TEST_CREATED_RO_ID)
(status, reason) = self.rosrs.deleteRO(snapshot_uri)
def testArchive(self):
rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, ro_test_config.ROSRS_ACCESS_TOKEN)
(copy_status, archiveUri) = self.createArchive(self.TEST_CREATED_RO_ID, self.TEST_SNAPHOT_ID, False)
assert copy_status == "DONE"
(status, reason, data, evo_type) = rosrs.getROEvolution(archiveUri)
assert evo_type == 3
self.freeze(archiveUri)
(status, reason, data, evo_type) = rosrs.getROEvolution(archiveUri)
assert evo_type == 2
(status, reason) = self.rosrs.deleteRO(self.TEST_CREATED_RO_ID)
(status, reason) = self.rosrs.deleteRO(archiveUri)
class TestROSRS_Session(unittest.TestCase):
"""
This test suite tests the ROSRS_Session client implementation of the ROSRS API
"""
def setUp(self):
super(TestROSRS_Session, self).setUp()
self.rosrs = ROSRS_Session(Config.ROSRS_API_URI,
accesskey=Config.AUTHORIZATION)
# Clean up from previous runs
self.rosrs.deleteRO(Config.TEST_RO_PATH, purge=True)
self.createdTestRO = None
return
def tearDown(self):
super(TestROSRS_Session, self).tearDown()
# Clean up
self.rosrs.deleteRO(Config.TEST_RO_PATH)
if self.createdTestRO:
self.rosrs.deleteRO(self.createdTestRO, purge=True)
self.rosrs.close()
return
def createTestRO(self):
(status, reason, rouri, manifest) = self.rosrs.createRO(Config.TEST_RO_NAME,
"Test RO for ROSRS_Session", "TestROSRS_Session.py", "2012-09-06")
self.assertEqual(status, 201)
self.createdTestRO = rouri
return (status, reason, rouri, manifest)
# Actual tests follow
def testHelpers(self):
testSplitValues()
testParseLinks()
return
def testListROs(self):
ros = self.rosrs.listROs()
return
def testCreateRO(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
self.assertEqual(str(rouri)[:len(Config.TEST_RO_URI)-1]+"/", Config.TEST_RO_URI)
self.assertIn((rouri, RDF.type, RO.ResearchObject), manifest)
rolist = self.rosrs.listROs()
self.assertIn(str(rouri), [ r["uri"] for r in rolist ])
return
def testDeleteRO(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Test that new RO is in collection
rolist = self.rosrs.listROs()
self.assertIn(str(rouri), [ r["uri"] for r in rolist ])
# Delete RO
(status, reason) = self.rosrs.deleteRO(rouri)
self.assertEqual(status, 204)
self.assertEqual(reason, "No Content")
# Test that new RO is not in collection
rolist = self.rosrs.listROs()
self.assertNotIn(str(rouri), [ r["uri"] for r in rolist ])
# Delete again
(status, reason) = self.rosrs.deleteRO(rouri)
self.assertEqual(status, 404)
self.assertEqual(reason, "Not Found")
return
def testGetROManifest(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Get manifest
(status, reason, headers, manifesturi, manifest) = self.rosrs.getROManifest(rouri)
self.assertEqual(status, 200)
self.assertEqual(reason, "OK")
self.assertEqual(headers["content-type"], "application/rdf+xml")
# Check manifest RDF graph
self.assertIn((rouri, RDF.type, RO.ResearchObject), manifest)
self.assertIn((rouri, DCTERMS.creator, None), manifest)
self.assertIn((rouri, DCTERMS.created, None), manifest)
self.assertIn((rouri, ORE.isDescribedBy, manifesturi), manifest)
return
def testGetROPage(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Get landing page
(status, reason, headers, pageuri, page) = self.rosrs.getROLandingPage(rouri)
self.assertEqual(status, 200)
self.assertEqual(reason, "OK")
self.assertEqual(headers["content-type"], "text/html;charset=UTF-8")
return
def testGetROZip(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Get manifest
(status, reason, headers, datauri, data) = self.rosrs.getROZip(rouri)
self.assertEqual(status, 200)
self.assertEqual(reason, "OK")
self.assertEqual(headers["content-type"], "application/zip")
# @@TODO test content of zip (data)?
return
def testAggregateResourceInt(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Aggregate internal resource
rescontent = "Resource content\n"
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt(
rouri, "test/path", ctype="text/plain", body=rescontent)
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
self.assertEqual(str(resuri), str(rouri)+"test/path")
# GET content
(status, reason, headers, uri, data) = self.rosrs.getROResource(
"test/path", rouri)
self.assertEqual(status, 200)
self.assertEqual(headers["content-type"], "text/plain")
self.assertEqual(data, rescontent)
# GET proxy
(getproxyuri, manifest) = self.rosrs.getROResourceProxy(
"test/path", rouri=rouri)
self.assertEqual(getproxyuri, proxyuri)
return
def testDeleteResourceInt(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create test resource
rescontent = "Resource content\n"
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt(
rouri, "test/path", ctype="text/plain", body=rescontent)
self.assertEqual(status, 201)
# GET content
(status, reason, headers, uri, data) = self.rosrs.getROResource(
"test/path", rouri)
self.assertEqual(status, 200)
# Delete resource
(status, reason) = self.rosrs.removeResource(rouri, resuri)
self.assertEqual(status, 204)
self.assertEqual(reason, "No Content")
# Check that resource is no longer available
(status, reason, headers, uri, data) = self.rosrs.getROResource(resuri)
self.assertEqual(status, 404)
return
def testAggregateResourceExt(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Aggregate external resource
externaluri = rdflib.URIRef("http://example.com/external/resource.txt")
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceExt(
rouri, externaluri)
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
self.assertEqual(resuri, externaluri)
# GET proxy (note: using rdflib.URIRef value for path)
(getproxyuri, manifest) = self.rosrs.getROResourceProxy(
externaluri, rouri)
self.assertEqual(getproxyuri, proxyuri)
return
def testDeleteResourceExt(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create test resource
externaluri = rdflib.URIRef("http://example.com/external/resource.txt")
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceExt(
rouri, externaluri)
self.assertEqual(status, 201)
self.assertEqual(resuri, externaluri)
# GET proxy (note: using rdflib.URIRef for path)
(getproxyuri, manifest) = self.rosrs.getROResourceProxy(
externaluri, rouri)
self.assertEqual(getproxyuri, proxyuri)
# Delete resource
(status, reason) = self.rosrs.removeResource(rouri, resuri)
self.assertEqual(status, 204)
self.assertEqual(reason, "No Content")
(getproxyuri, manifest) = self.rosrs.getROResourceProxy(
externaluri, rouri)
self.assertIsNone(getproxyuri)
self.assertIsNotNone(manifest)
return
def testGetROResource(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create test resource
rescontent = "Resource content\n"
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt(
rouri, "test/path", ctype="text/plain", body=rescontent)
self.assertEqual(status, 201)
# GET content
(status, reason, headers, uri, data) = self.rosrs.getROResource(
"test/path", rouri)
self.assertEqual(status, 200)
self.assertEqual(reason, "OK")
self.assertEqual(headers["content-type"], "text/plain")
self.assertEqual(data, rescontent)
return
def testGetROResourceRDF(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create internal test resource
rescontent = """<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:dct="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
>
<rdf:Description rdf:about="http://example.org/file1.txt">
<dct:title>Title for file1.txt</dct:title>
</rdf:Description>
</rdf:RDF>
"""
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt(
rouri, "test/file1.rdf", ctype="application/rdf+xml", body=rescontent)
self.assertEqual(status, 201)
# Get resource content
(status, reason, headers, uri, graph)= self.rosrs.getROResourceRDF(
"test/file1.rdf", rouri=rouri)
self.assertEqual(status, 200)
self.assertEqual(reason, "OK")
self.assertEqual(headers["content-type"], "application/rdf+xml")
s = rdflib.URIRef("http://example.org/file1.txt")
self.assertIn((s, DCTERMS.title, rdflib.Literal("Title for file1.txt")), graph)
return
def testGetROResourceProxy(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create internal test resource
rescontent = "Resource content\n"
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt(
rouri, "test/path", ctype="text/plain", body=rescontent)
self.assertEqual(status, 201)
# Get resource proxy
(getproxyuri, manifest) = self.rosrs.getROResourceProxy(
"test/path", rouri=rouri)
self.assertEqual(getproxyuri, proxyuri)
return
def testCreateROAnnotationInt(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create internal test resource
rescontent = "Resource content\n"
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt(
rouri, "test/file.txt", ctype="text/plain", body=rescontent)
self.assertEqual(status, 201)
# Create internal annotation
annbody = """<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:dct="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xml:base="%s"
>
<rdf:Description rdf:about="test/file.txt">
<dct:title>Title for test/file.txt</dct:title>
<rdfs:seeAlso rdf:resource="http://example.org/test" />
</rdf:Description>
</rdf:RDF>
"""%(str(rouri))
agraph = rdflib.graph.Graph()
agraph.parse(data=annbody, format="xml")
(status, reason, annuri, bodyuri) = self.rosrs.createROAnnotationInt(
rouri, resuri, agraph)
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
# Retrieve annotation URIs
auris = list(self.rosrs.getROAnnotationUris(rouri, resuri))
self.assertIn(annuri, auris)
buris = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri))
### self.assertIn(bodyuri, buris)
# Retrieve annotation
(status, reason, bodyuri, anngr) = self.rosrs.getROAnnotation(annuri)
self.assertEqual(status, 200)
self.assertEqual(reason, "OK")
self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title for test/file.txt")), anngr)
self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test")), anngr)
return
def testGetROAnnotationGraph(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create internal test resource
rescontent = "Resource content\n"
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt(
rouri, "test/file.txt", ctype="text/plain", body=rescontent)
self.assertEqual(status, 201)
# Create internal annotation
annbody = """<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:dct="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xml:base="%s"
>
<rdf:Description rdf:about="test/file.txt">
<dct:title>Title for test/file.txt</dct:title>
<rdfs:seeAlso rdf:resource="http://example.org/test" />
</rdf:Description>
</rdf:RDF>
"""%(str(rouri))
agraph = rdflib.graph.Graph()
agraph.parse(data=annbody, format="xml")
(status, reason, annuri, bodyuri) = self.rosrs.createROAnnotationInt(
rouri, resuri, agraph)
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
# Retrieve merged annotations
anngr = self.rosrs.getROAnnotationGraph(rouri, resuri)
annts = list(anngr.triples((None, None, None)))
self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title for test/file.txt")), annts)
self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test")), annts)
return
def testCreateROAnnotationExt(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create external test resource
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceExt(
rouri, rdflib.URIRef("http://example.org/ext"))
self.assertEqual(status, 201)
# Create annotation using external body reference
bodyuri = rdflib.URIRef("http://example.org/ext/ann.rdf")
(status, reason, annuri) = self.rosrs.createROAnnotationExt(rouri, resuri, bodyuri)
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
# Retrieve annotation URIs
auris = list(self.rosrs.getROAnnotationUris(rouri, resuri))
self.assertIn(annuri, auris)
buris = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri))
### self.assertIn(bodyuri, buris)
return
def testUpdateROAnnotationInt(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create internal test resource
rescontent = "Resource content\n"
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt(
rouri, "test/file.txt", ctype="text/plain", body=rescontent)
self.assertEqual(status, 201)
# Create internal annotation
annbody1 = """<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:dct="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xml:base="%s"
>
<rdf:Description rdf:about="test/file.txt">
<dct:title>Title 1</dct:title>
<rdfs:seeAlso rdf:resource="http://example.org/test1" />
</rdf:Description>
</rdf:RDF>
"""%(str(rouri))
agraph1 = rdflib.graph.Graph()
agraph1.parse(data=annbody1, format="xml")
(status, reason, annuri, bodyuri1) = self.rosrs.createROAnnotationInt(
rouri, resuri, agraph1)
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
# Retrieve annotation URIs
auris1 = list(self.rosrs.getROAnnotationUris(rouri, resuri))
self.assertIn(annuri, auris1)
buris1 = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri))
### self.assertIn(bodyuri1, buris1)
# Retrieve annotation
(status, reason, auri1, anngr1a) = self.rosrs.getROAnnotation(annuri)
self.assertEqual(status, 200)
self.assertEqual(reason, "OK")
annts1a = list(anngr1a.triples((None, None, None)))
self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title 1")), annts1a)
self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test1")), annts1a)
# Retrieve merged annotations
anngr1b = self.rosrs.getROAnnotationGraph(rouri, resuri)
annts1b = list(anngr1b.triples((None, None, None)))
self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title 1")), annts1b)
self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test1")), annts1b)
# Update internal annotation
annbody2 = """<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:dct="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xml:base="%s"
>
<rdf:Description rdf:about="test/file.txt">
<dct:title>Title 2</dct:title>
<rdfs:seeAlso rdf:resource="http://example.org/test2" />
</rdf:Description>
</rdf:RDF>
"""%(str(rouri))
agraph2 = rdflib.graph.Graph()
agraph2.parse(data=annbody2, format="xml")
(status, reason, bodyuri2) = self.rosrs.updateROAnnotationInt(
rouri, annuri, resuri, agraph2)
self.assertEqual(status, 200)
self.assertEqual(reason, "OK")
# Retrieve annotation URIs
auris2 = list(self.rosrs.getROAnnotationUris(rouri, resuri))
self.assertIn(annuri, auris2)
buris2 = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri))
### self.assertIn(bodyuri2, buris2)
# Retrieve annotation
(status, reason, auri2a, anngr2a) = self.rosrs.getROAnnotation(annuri)
annts2a = list(anngr2a.triples((None, None, None)))
self.assertEqual(status, 200)
self.assertEqual(reason, "OK")
self.assertNotIn((resuri, DCTERMS.title, rdflib.Literal("Title 1")), annts2a)
self.assertNotIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test1")), annts2a)
self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title 2")), annts2a)
self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test2")), annts2a)
# Retrieve merged annotations
anngr2b = self.rosrs.getROAnnotationGraph(rouri, resuri)
annts2b = list(anngr2b.triples((None, None, None)))
self.assertNotIn((resuri, DCTERMS.title, rdflib.Literal("Title 1")), annts2b)
self.assertNotIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test1")), annts2b)
self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title 2")), annts2b)
self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test2")), annts2b)
return
def testUpdateROAnnotationExt(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create external test resource
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceExt(
rouri, rdflib.URIRef("http://example.org/ext"))
self.assertEqual(status, 201)
# Create annotation using external body reference
bodyuri1 = rdflib.URIRef("http://example.org/ext/ann1.rdf")
(status, reason, annuri) = self.rosrs.createROAnnotationExt(rouri, resuri, bodyuri1)
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
# Retrieve annotation URIs
auris1 = list(self.rosrs.getROAnnotationUris(rouri, resuri))
self.assertIn(annuri, auris1)
buris1 = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri))
self.assertIn(bodyuri1, buris1)
# Update annotation using external body reference
# @@TODO - this doesn't check that old annotation is removed.
# @@TODO - currently, update is not fully implemented (2013-05).
bodyuri2 = rdflib.URIRef("http://example.org/ext/ann2.rdf")
(status, reason, annuri) = self.rosrs.createROAnnotationExt(rouri, resuri, bodyuri2)
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
# Retrieve annotation URIs
auris2 = list(self.rosrs.getROAnnotationUris(rouri, resuri))
self.assertIn(annuri, auris2)
buris2 = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri))
self.assertIn(bodyuri1, buris2)
return
def testRemoveROAnnotation(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
# Create internal test resource
rescontent = "Resource content\n"
(status, reason, proxyuri, resuri) = self.rosrs.aggregateResourceInt(
rouri, "test/file.txt", ctype="text/plain", body=rescontent)
self.assertEqual(status, 201)
# Create internal annotation
annbody = """<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:dct="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xml:base="%s"
>
<rdf:Description rdf:about="test/file.txt">
<dct:title>Title for test/file.txt</dct:title>
<rdfs:seeAlso rdf:resource="http://example.org/test" />
</rdf:Description>
</rdf:RDF>
"""%(str(rouri))
agraph = rdflib.graph.Graph()
agraph.parse(data=annbody, format="xml")
(status, reason, annuri, bodyuri) = self.rosrs.createROAnnotationInt(
rouri, resuri, agraph)
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
# Retrieve annotation URIs
auris = list(self.rosrs.getROAnnotationUris(rouri, resuri))
self.assertIn(annuri, auris)
buris = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri))
### self.assertIn(bodyuri, buris)
# Remove the annotation
(status, reason) = self.rosrs.removeROAnnotation(rouri, annuri)
self.assertEqual(status, 204)
self.assertEqual(reason, "No Content")
# Retrieve annotation URIs
auris = list(self.rosrs.getROAnnotationUris(rouri, resuri))
self.assertNotIn(annuri, auris)
buris = list(self.rosrs.getROAnnotationBodyUris(rouri, resuri))
### self.assertNotIn(bodyuri, buris)
return
# Evolution tests
def testCopyRO(self):
return
def testCancelCopyRO(self):
return
def testUpdateROStatus(self):
return
def testGetROEvolution(self):
return
# Sentinel/placeholder tests
def testUnits(self):
assert (True)
def testComponents(self):
assert (True)
def testIntegration(self):
assert (True)
def testPending(self):
assert (False), "Pending tests follow"
class TestEvoCommands(TestROEVOSupport.TestROEVOSupport):
TEST_RO_ID = "ro-manger-evo-test-ro"
TEST_SNAPHOT_ID = "ro-manager-evo-test-snaphot"
TEST_ARCHIVE_ID = "ro-manager-evo-test-archive-id"
TEST_UNDEFINED_ID = "ro-manager-evo-test-undefined-id"
CREATED_RO = ""
def setUp(self):
super(TestEvoCommands, self).setUp()
self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN)
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
(status, reason, rouri, manifest) = self.rosrs.createRO(self.TEST_RO_ID,
"Test RO for ROEVO", "Test Creator", "2012-09-06")
self.CREATED_RO = rouri;
return
def tearDown(self):
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
(status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID+"/")
(status, reason) = self.rosrs.deleteRO(self.CREATED_RO)
super(TestEvoCommands, self).tearDown()
return
def testSnapshot(self):
"""
snapshot <live-RO> <snapshot-id> [ --asynchronous ] [ --freeze ] [ -t <access_token> ] [ -t <token> ]
"""
return
def testSnapshotAsynchronous(self):
args = [
"ro", "snapshot" , str(self.CREATED_RO), self.TEST_SNAPHOT_ID,
"--asynchronous",
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-r", ro_test_config.ROSRS_URI,
"-v"
]
outLines = ""
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
# simple check if the verbouse mode works well
for word in ("ro snapshot --asynchronous "+ro_test_config.ROSRS_URI + self.TEST_RO_ID + " " + self.TEST_SNAPHOT_ID).split(" "):
self.assertTrue(self.outstr.getvalue().count(word+ " ") or self.outstr.getvalue().count(" " + word), "snapshot command wasn't parse well")
self.assertEqual(self.outstr.getvalue().count("Job Status: "), 1)
self.assertEqual(self.outstr.getvalue().count("Job URI: "), 1)
self.assertEqual(self.outstr.getvalue().count("Target URI: "), 1)
self.assertEqual(self.outstr.getvalue().count("Target Name: "), 1)
self.assertEqual(self.outstr.getvalue().count("Response Status: "), 1)
self.assertEqual(self.outstr.getvalue().count("Response Reason: "), 1)
outLines = self.outstr.getvalue().split("\n")
for line in outLines:
if "Job URI:" in line:
jobLocation = line.split("Job URI:")[1].strip()
status = "RUNNING"
while status == "RUNNING":
(status, id) = parse_job(self.rosrs, jobLocation)
assert status == "DONE"
self.rosrs.deleteRO(id)
return
def testSnapshotSynchronous(self):
args = [
"ro", "snapshot", self.CREATED_RO, self.TEST_SNAPHOT_ID,
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-r", ro_test_config.ROSRS_URI,
"-v"
]
outLines = ""
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
# simple check if the verbouse mode works well
for word in ("ro snaphot "+ro_test_config.ROSRS_URI + self.TEST_RO_ID + " " + self.TEST_SNAPHOT_ID).split(" "):
self.assertTrue(self.outstr.getvalue().count(word+ " ") or self.outstr.getvalue().count(" " + word), "snapshot command wasn't parse well")
self.assertEqual(self.outstr.getvalue().count("Target URI: "), 1)
outLines = self.outstr.getvalue().split("\n")
for line in outLines:
if "Target URI:" in line:
id = line.split("Target URI:")[1].strip()
self.rosrs.deleteRO(id)
return
def testSnapshotWithEscOption(self):
args = [
"ro", "snapshot", self.CREATED_RO, self.TEST_SNAPHOT_ID,
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-r", ro_test_config.ROSRS_URI,
"-v"
]
outLines = ""
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
# simple check if the verbouse mode works well
self.assertEqual(self.outstr.getvalue().count("--asynchronous"), 0, "shouldn't be asynchronous")
outLines = self.outstr.getvalue().split("\n")
for line in outLines:
if "Target URI:" in line:
id = line.split("Target URI:")[1].strip()
self.rosrs.deleteRO(id)
return
def testArchive(self):
"""
archive <live-RO> <snapshot-id> [ --asynchronous ] [ --freeze ] [ -t <access_token> ] [ -t <token> ]
"""
return
def testArchiveAsynchronous(self):
args = [
"ro", "archive" , str(self.CREATED_RO), self.TEST_SNAPHOT_ID,
"--asynchronous",
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-r", ro_test_config.ROSRS_URI,
"-v"
]
outLines = ""
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
# simple check if the verbouse mode works well
for word in ("ro archive --asynchronous "+ro_test_config.ROSRS_URI + self.TEST_RO_ID + " " + self.TEST_SNAPHOT_ID).split(" "):
self.assertTrue(self.outstr.getvalue().count(word+ " ") or self.outstr.getvalue().count(" " + word), "snapshot command wasn't parse well")
self.assertEqual(self.outstr.getvalue().count("Job Status: "), 1)
self.assertEqual(self.outstr.getvalue().count("Job URI: "), 1)
self.assertEqual(self.outstr.getvalue().count("Target URI: "), 1)
self.assertEqual(self.outstr.getvalue().count("Target Name: "), 1)
self.assertEqual(self.outstr.getvalue().count("Response Status: "), 1)
self.assertEqual(self.outstr.getvalue().count("Response Reason: "), 1)
outLines = self.outstr.getvalue().split("\n")
for line in outLines:
if "Job URI:" in line:
jobLocation = line.split("Job URI:")[1].strip()
status = "RUNNING"
while status == "RUNNING":
(status, id) = parse_job(self.rosrs, jobLocation)
assert status == "DONE"
self.rosrs.deleteRO(id)
return
def testArchiveSynchronous(self):
args = [
"ro", "archive", ro_test_config.ROSRS_URI + self.TEST_RO_ID, ro_test_config.ROSRS_URI + self.TEST_SNAPHOT_ID,
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-r", ro_test_config.ROSRS_URI,
"-v"
]
outLines = ""
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
# simple check if the verbouse mode works well
self.assertEqual(self.outstr.getvalue().count("--asynchronous"), 0, "shouldn't be asynchronous")
outLines = self.outstr.getvalue().split("\n")
for line in outLines:
if "Target URI:" in line:
id = line.split("Target URI:")[1].strip()
self.rosrs.deleteRO(id)
return
def testFreeze(self):
"""
freeze <RO-id>
"""
#preapre snaphot
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
(status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID+"/")
(status, reason, createdRoUri, manifest) = self.rosrs.createRO(self.TEST_RO_ID,
"Test RO for ROEVO", "Test Creator", "2012-09-06")
(createdSnapshotStatus, createdSnapshotId) = self.createSnapshot(createdRoUri, self.TEST_SNAPHOT_ID, False)
args = [
"ro", "freeze",str(createdSnapshotId),
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-r", ro_test_config.ROSRS_URI,
"-v"
]
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
self.assertEqual(self.outstr.getvalue().count("freeze operation finished successfully"), 1)
(status, reason) = self.rosrs.deleteRO(createdRoUri)
(status, reason) = self.rosrs.deleteRO(createdSnapshotId)
return
def FreezeNonExistetSnaphot(self):
"""
freeze <RO-id>
"""
#preapre snaphot
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
(status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID+"/")
(status, reason, rouri, manifest) = self.rosrs.createRO(self.TEST_RO_ID,
"Test RO for ROEVO", "Test Creator", "2012-09-06")
self.createSnapshot(self.TEST_RO_ID+"/", self.TEST_SNAPHOT_ID, True)
args = [
"ro", "freeze", self.TEST_SNAPHOT_RO_ID + "non exited",
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-r", ro_test_config.ROSRS_URI,
"-v"
]
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == -1
self.assertEqual(self.outstr.getvalue().count("Given URI isn't correct"), 0)
(status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID+"/")
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
return
def testRemoteStatusSnapshotRO(self):
self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN)
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
(status, reason, createdRoUri, manifest) = self.rosrs.createRO(self.TEST_RO_ID,
"Test RO for ROEVO", "Test Creator", "2012-09-06")
(status, reason) = self.rosrs.deleteRO(self.TEST_SNAPHOT_ID + "/")
(createdSnapshotStatus, createdSnapshotUri) = self.createSnapshot(createdRoUri, self.TEST_SNAPHOT_ID, True)
args = [
"ro", "status", str(createdSnapshotUri),
"-r", ro_test_config.ROSRS_URI,
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-v"
]
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
outtxt = self.outstr.getvalue()
self.assertEqual(outtxt.count("SNAPSHOT"), 1)
(status, reason) = self.rosrs.deleteRO(createdSnapshotUri)
(status, reason) = self.rosrs.deleteRO(createdRoUri)
return
def testRemoteStatusArchiveRO(self):
self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN)
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
(status, reason, createdRoUri, manifest) = self.rosrs.createRO(self.TEST_RO_ID,
"Test RO for ROEVO", "Test Creator", "2012-09-06")
(status, reason) = self.rosrs.deleteRO(self.TEST_ARCHIVE_ID + "/")
(createdArchiveStatus, createdArchiveUri) = self.createArchive(createdRoUri, self.TEST_ARCHIVE_ID, True)
args = [
"ro", "status", str(createdArchiveUri),
"-r", ro_test_config.ROSRS_URI,
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-v"
]
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
outtxt = self.outstr.getvalue()
self.assertEqual(outtxt.count("ARCHIVE"), 1)
(status, reason) = self.rosrs.deleteRO(createdArchiveUri)
(status, reason) = self.rosrs.deleteRO(createdRoUri)
return
def testRemoteStatusUndefinedRO(self):
self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN)
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
(status, reason, createdRoUri, manifest) = self.rosrs.createRO(self.TEST_RO_ID,
"Test RO for ROEVO", "Test Creator", "2012-09-06")
(status, reason) = self.rosrs.deleteRO(self.TEST_ARCHIVE_ID + "/")
(createdArchiveStatus, createdArchiveUri) = self.createArchive(createdRoUri, self.TEST_ARCHIVE_ID, False)
args = [
"ro", "status", str(createdArchiveUri),
"-r", ro_test_config.ROSRS_URI,
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-v"
]
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
outtxt = self.outstr.getvalue()
self.assertEqual(outtxt.count("UNDEFINED"), 1)
(status, reason) = self.rosrs.deleteRO(createdArchiveUri)
(status, reason) = self.rosrs.deleteRO(createdRoUri)
return
def testRemoteStatusLiveRO(self):
self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN)
(status, reason) = self.rosrs.deleteRO(self.TEST_RO_ID+"/")
(status, reason, rouri, manifest) = self.rosrs.createRO(self.TEST_RO_ID,
"Test RO for ROEVO", "Test Creator", "2012-09-06")
args = [
"ro", "status", str(rouri),
"-r", ro_test_config.ROSRS_URI,
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-v"
]
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
assert status == 0
outtxt = self.outstr.getvalue()
self.assertEqual(outtxt.count("LIVE"), 1)
(status, reason) = self.rosrs.deleteRO(rouri)
return
def testRemoteStatusWithWrongUriGiven(self):
self.rosrs = ROSRS_Session(ro_test_config.ROSRS_URI, accesskey=ro_test_config.ROSRS_ACCESS_TOKEN)
self.rosrs.deleteRO(self.TEST_RO_ID + "/")
self.rosrs.deleteRO("some-strange-uri/")
args = [
"ro", "status", ro_test_config.ROSRS_URI + "some-strange-uri/",
"-r", ro_test_config.ROSRS_URI,
"-t", ro_test_config.ROSRS_ACCESS_TOKEN,
"-v"
]
with SwitchStdout(self.outstr):
status = ro.runCommand(ro_test_config.CONFIGDIR, ro_test_config.ROBASEDIR, args)
outtxt = self.outstr.getvalue()
assert status == -1
self.assertEqual(outtxt.count("Wrong URI was given"), 1)
self.rosrs.deleteRO(self.TEST_RO_ID + "/")
return
class TestROSRSMetadata(TestROSupport.TestROSupport):
"""
Test ro metadata access via ROSRS API
"""
def setUp(self):
super(TestROSRSMetadata, self).setUp()
self.rosrs = ROSRS_Session(Config.ROSRS_API_URI,
accesskey=Config.AUTHORIZATION)
# Clean up from previous runs
self.rosrs.deleteRO(Config.TEST_RO_PATH)
return
def tearDown(self):
super(TestROSRSMetadata, self).tearDown()
# Clean up
self.rosrs.deleteRO(Config.TEST_RO_PATH)
self.rosrs.close()
return
def createTestRO(self):
(status, reason, rouri, manifest) = self.rosrs.createRO(Config.TEST_RO_NAME,
"Test RO for ROSRSMetadata", "TestROSRSMetadata.py", "2012-09-11")
self.assertEqual(status, 201)
# Include manifest as annotation of RO
(s1, r1, h1, manifesturi, manifest) = self.rosrs.getROManifest(rouri)
self.assertEqual(s1, 200)
(s2, r2, annuri) = self.rosrs.createROAnnotationExt(
rouri, rouri, manifesturi)
self.assertEqual(s2, 201)
# Aggregate internal resource
rescontent = "Resource content\n"
(s3, r3, proxyuri, resuri) = self.rosrs.aggregateResourceInt(
rouri, Config.TEST_RESOURCE, ctype="text/plain", body=rescontent)
self.assertEqual(s3, 201)
self.assertEqual(r3, "Created")
self.assertEqual(str(resuri), str(rouri)+Config.TEST_RESOURCE)
# Aggregate external resource
externaluri = rdflib.URIRef(Config.TEST_EXTERNAL)
(s4, r4, proxyuri, resuri) = self.rosrs.aggregateResourceExt(
rouri, externaluri)
self.assertEqual(s4, 201)
self.assertEqual(r4, "Created")
self.assertEqual(str(resuri), Config.TEST_EXTERNAL)
return (status, reason, rouri, manifest)
def createTestAnnotation(self, rouri, resuri, resref):
annbody = """<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:dct="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xml:base="%(rouri)s"
>
<rdf:Description rdf:about="%(resuri)s">
<dct:title>Title for %(resref)s</dct:title>
<rdfs:seeAlso rdf:resource="http://example.org/test" />
</rdf:Description>
</rdf:RDF>
"""%{"rouri": str(rouri), "resuri": str(resuri), "resref": resref}
agraph = rdflib.graph.Graph()
agraph.parse(data=annbody, format="xml")
(status, reason, annuri, bodyuri) = self.rosrs.createROAnnotationInt(
rouri, resuri, agraph)
self.assertEqual(status, 201)
return (status, reason, annuri, bodyuri)
# Actual tests follow
def testNull(self):
assert True, 'Null test failed'
def testCreateRoMetadata(self):
"""
Test creation of ro_metadata object, and basic access to manifest content
"""
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
self.assertEqual(str(rouri), Config.TEST_RO_URI)
self.assertIn((rouri, RDF.type, RO.ResearchObject), manifest)
romd = ro_metadata.ro_metadata(ro_config, rouri)
resuri = romd.getComponentUriAbs(Config.TEST_RESOURCE)
exturi = romd.getComponentUriAbs(Config.TEST_EXTERNAL)
resref = Config.TEST_RESOURCE
(status, reason, annuri, bodyuri) = self.createTestAnnotation(rouri, resuri, resref)
self.assertEqual(status, 201)
self.assertEqual(reason, "Created")
#
self.assertEquals(romd.rouri, rouri)
self.assertTrue(romd.roManifestContains((rouri, RDF.type, RO.ResearchObject)))
self.assertTrue(romd.roManifestContains((rouri, ORE.aggregates, resuri)))
self.assertTrue(romd.roManifestContains((rouri, ORE.aggregates, exturi)))
return
def testReadRoAnnotationBody(self):
"""
Test function to create & read a simple annotation body on an RO
"""
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
romd = ro_metadata.ro_metadata(ro_config, rouri)
resuri = romd.getComponentUriAbs(Config.TEST_RESOURCE)
resref = Config.TEST_RESOURCE
(status, reason, bodyuri, agraph) = self.createTestAnnotation(rouri, resuri, resref)
self.assertEqual(status, 201)
# Retrieve annotations
anns = list(romd.getFileAnnotations(Config.TEST_RESOURCE))
self.assertIn((resuri, DCTERMS.title, rdflib.Literal("Title for "+Config.TEST_RESOURCE)), anns)
self.assertIn((resuri, RDFS.seeAlso, rdflib.URIRef("http://example.org/test")), anns)
return
def testGetInitialRoAnnotations(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
romd = ro_metadata.ro_metadata(ro_config, rouri)
# Retrieve the anotations
annotations = romd.getRoAnnotations()
rouri = romd.getRoUri()
expected_annotations = (
[ (rouri, RDF.type, RO.ResearchObject)
, (rouri, RDF.type, ROEVO.LiveRO)
, (rouri, ORE.isDescribedBy, romd.getComponentUriAbs(ro_test_config.ROMANIFESTPATH))
#, (rouri, DCTERMS.description, rdflib.Literal('Test init RO annotation'))
#, (rouri, DCTERMS.title, rdflib.Literal('Test init RO annotation'))
#, (rouri, DCTERMS.created, rdflib.Literal('unknown'))
#, (rouri, DCTERMS.creator, rdflib.Literal('Test User'))
#, (rouri, DCTERMS.identifier, rdflib.Literal('ro-testRoAnnotate'))
])
count = 0
for next in list(annotations):
if ( not isinstance(next[2], rdflib.BNode) and
not next[1] in [ORE.aggregates, DCTERMS.created, DCTERMS.creator] ):
log.debug("- next %s"%(str(next[0])) )
log.debug(" - (%s, %s)"%(str(next[1]),str(next[2])) )
if next in expected_annotations:
count += 1
else:
self.assertTrue(False, "Not expected (%d) %s"%(count, repr(next)))
self.assertEqual(count,3)
return
def testQueryAnnotations(self):
(status, reason, rouri, manifest) = self.createTestRO()
self.assertEqual(status, 201)
romd = ro_metadata.ro_metadata(ro_config, rouri)
resuri = romd.getComponentUriAbs(Config.TEST_RESOURCE)
resref = Config.TEST_RESOURCE
(status, reason, bodyuri, agraph) = self.createTestAnnotation(rouri, resuri, resref)
self.assertEqual(status, 201)
# Query the file anotations
queryprefixes = """
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX ro: <http://purl.org/wf4ever/ro#>
PREFIX ore: <http://www.openarchives.org/ore/terms/>
PREFIX ao: <http://purl.org/ao/>
PREFIX dcterms: <http://purl.org/dc/terms/>
PREFIX roterms: <http://ro.example.org/ro/terms/>
"""
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator ?user .
}
""")
resp = romd.queryAnnotations(query)
self.assertTrue(resp, "Expected 'True' result for query: %s"%(query))
query = (queryprefixes +
"""
ASK
{
<%(resuri)s> dcterms:title ?title .
}
"""%{"resuri": str(resuri)})
resp = romd.queryAnnotations(query)
self.assertTrue(resp, "Expected 'True' result for query: %s"%(query))
query = (queryprefixes +
"""
ASK
{
?ro rdf:type ro:ResearchObject ;
dcterms:creator "Not user" .
}
""")
resp = romd.queryAnnotations(query)
self.assertFalse(resp, "Expected 'False' result for query: %s"%(query))
query = (queryprefixes +
"""
SELECT * WHERE
{
?ro rdf:type ro:ResearchObject ;
ore:aggregates ?file .
?file dcterms:title ?title .
}
""")
rouri = romd.getRoUri()
resp = romd.queryAnnotations(query)
self.assertEqual(resp[0]['ro'], rouri)
self.assertEqual(resp[0]['file'], resuri)
self.assertEqual(resp[0]['title'], rdflib.Literal("Title for %s"%(Config.TEST_RESOURCE)))
return
# Sentinel/placeholder tests
def testUnits(self):
assert (True)
def testComponents(self):
assert (True)
def testIntegration(self):
assert (True)
def testPending(self):
assert (False), "Pending tests follow"
